{% extends "base.html" %} {% block body %}

Todo

https://www.acmicpc.net/problem/14041 

https://www.acmicpc.net/problem/8295 

https://www.acmicpc.net/problem/15151 

BJE_15858 Simple Arithmetic (Bronze III) 

BJ_1871 좋은 자동차 번호판 (Bronze II)

BJ_2153 소수 단어 (Bronze II)

BJ_2386 도비의 영어공부 (Bronze II) 

BJ_2408 큰 수 계산 (Bronze II) 

BJ_1526 가장 큰 금민수 (Bronze I)

BJ_4641 Doubles (Bronze I)

BJ_1236 성 지키기 (Bronze I) 

BJ_11098 첼시를 도와줘 (Bronze I)

BJ_6996 애너그램 (Bronze I)

BJ_11179 2진수 뒤집기 (Bronze I)

BJ_8974 희주의 수학시험 (Bronze I)

BJ_1402 아무래도이문제는A번난이도인것같다 (Bronze I)

BJ_11091 알파벳 전부 쓰기 (Bronze I)

https://www.acmicpc.net/problem/10867 

https://www.acmicpc.net/problem/2578 

https://www.acmicpc.net/problem/5635 

https://www.acmicpc.net/problem/1063 

https://www.acmicpc.net/problem/2998 

https://www.acmicpc.net/problem/5800 

https://www.acmicpc.net/problem/1145 

https://www.acmicpc.net/problem/10158 

https://www.acmicpc.net/problem/2670 

https://www.acmicpc.net/problem/5347 

https://www.acmicpc.net/problem/11332


Page

UI

Implementation

Students can create id / pw


Teaching

Resources

VSCode | LC | BJ | Kattis

https://www.youtube.com/watch?v=5Wju2JKyNLY 

https://code.visualstudio.com/docs/remote/wsl-tutorial 

Get-Content a.txt | python a.py

파이썬 온라인 디버거 (vs 코드 다운 받기 힘든 저학년 위주)

영어 시험 문제집 

BJ | solved

한글 코딩 문제집

https://chrome.google.com/webstore/detail/solvedac/anenheoccfogllpbpcmbbpcbjpogeehe?hl=ko 

Youtube | Google | docs

온라인 강좌 (가급적 자막 있는 Khan 720p → 없을 시 다른 한국 영상)

Youtube 1~2개 링크 후에 적절한 설명 (난이도 순)

예제 넣고 그에 맞는 GF 문제 만들기 (난이도 순)

설정에서 퀴즈로 만들기, 틀린 문제 정답공개 제거

답은 주관식으로 코드 문제는 (간단하게 코드 적고, 이것의 output은 어떻게 나오냐 식으로)

답 format 은 teaching student 에 기술 후 답 1개만 맞게 (이전 시험 참고)

대단원 (heading 1) | 소단원 (Heading 2)으로 분류 (ctrl + alt + 1 / 2)

소단원에는 • Practice • Test • Code 의 태그가 있음

학생용 링크므로 수정 안됨

황규승                                                                                # 질문자

https://www.acmicpc.net/problem/16430                                         # 문제

a, b = input()                                                                        # 현재 코드

ValueError: not enough values to unpack (expected 2, got 1)                # 에러 내용

    a, b = input()

Line 1 in <module> (Solution.py)

Preparation

학생 관리 명부

www.open.kattis.com 에서 아래에 문제 코드 입력해서 contest 만들기

        

시험 시작 시 Q&A 에 문제 올리기

일요일에 시험에 정답 teaching_stduent에 올리기

Khan academy 보게 시킨 후 GF / BJ 풀기

3반 친구들은 warm up GF 풀기, BJ로 개념 설명 → Kattis 시험 진행

Easy, Hard 문제 4개씩 BJ에 찾아서 올림

그 다음주는 정답 올리기 (즉 Teaching student에는 8개 시험 정답, 8개 숙제 정답, 8개 숙제가 있음)

Goorm

백준 코드 안될 때 진행

https://level.goorm.io/

Easy

홀짝 판별                 → if else

몫과 나머지                 → Quotient | Remainder

약수 구하기

최소값                         → min | max | abs

Substring                 → List | Indexing | Slicing

계산기                         → eval

피라미드                  → for

단어의 개수 세기         → len

거스름돈                 → Quotient | Remainder

Medium

문자열 뒤집기                 → reversed

공백 없애기                 → for

369 게임                 → Quotient | Remainder

약수의 합

구구단+

소수 판별                 → Prime | LCM | GCD

윤년                        → if | elif | else

이차 방정식의 해         → Exponent

        주사위 놀이                 → for

Hard

3과 5의 배수                 → Series

n 구하기                 → Series

절약 정신                 → Prime | LCM | GCD

Algorithm

[1] Print

Comment | Print

KIM_11 주석 

KIM_19 이스케이프 코드

#                                                        # single line comment

"""                                                        # multi line comment

written by: Sean Hwang

"""

KIM_05 출력하기

        Print(5)                                                # Error

        print(1, 2, 3)                                                # 1 2 3 (default)

print(5, 5, sep='-')                                        # 5-5

print(5)                                                        # 5

print(5)                                                        # 5

print(5, end=' ')                                        # 5 5

print(5, end=' ')

print(5, " is five")                                        # 5 is five

print(str(5) + " is five")                                        # 5 is five (cast)

11CE_comment|print (edit) 

11CE_comment|print

print(05)

print(1+'1')

        PRINT('123')

print(4.99)

print(--5)

print('1', 1)

print(9999)

print(3 + 5)

print(3.5)

print(ab)

11CH_comment|print(edit)

11CH_comment|print

print(5, 5, sep='-')

print(1, end='+'); print(2)

print(2, end='*'); print(3)

print('a', 'z', sep='.')

print('b', 'd', sep='@')

print('a', 1, sep='^')

print(123, end="0"); print(123)

print('ace', end="|"); print('bdf')

print('int', 'float', sep="bool")

print(98,'zxw',sep="::", end="**")

BJ_1237 정ㅋ벅ㅋ (Unrated)

print("문제의 정답")

BJ_10943 랜덤 게임~ (Unrated)

print(1)

BJ_2557 Hello World (Bronze V) 

print("Hello World!")

BJ_15962 새로운 시작 (Bronze V) 

print("파이팅!!")

BJ_14645 와이버스 부릉부릉 (Bronze V) 

print(‘비와이’)

BJ_10718 We love kriii (Bronze V) 

print("강한친구 대한육군")

print('강한친구 대한육군')

BJ_7287 등록 (Bronze V)

print(123)

print('Your_ICPC_Team_Name')

BJ_16170 오늘의 날짜는? (Bronze V) 

print(2020)

print('05')

print(23)

BJ_10699 오늘 날짜 (Bronze V)

print("2015-01-24")

KT_Hello (1.2) 

print("Hello World!")

Escape | Multiline

#18 독스트링 

여러줄 문자열 

print(" ' ")                                                # '

print(" ' \" ")                                                 # ' "

print("\n")                                                 # new line

print("\\")                                                 # \

print("\t Hello")                                         #         Hello

        

₩ 와 \ 는 같음

\"                                                        # Double Quote

\'                                                        # Single Quote        

\\                                                        # Backslash        

\n                                                        # New Line        

\r                                                        # Carriage Return        

\t                                                        # Tab        

12CE_Escape|multiline (edit) 

12CE_Escape|multiline

print("*")

print(" ' ")

print(" " ")

print(" \" ")

print(" \'\" ")

print("\")

print("\\")

print("line "1" ")

print(' ' ')

print(' \' ')

print("""line1                                                # print multi-line at the same time

line2

line3""")

        

BJ_9653 스타워즈 로고 (Bronze V) 

print("""    8888888888  888    88888

   88     88   88 88   88  88

    8888  88  88   88  88888

       88 88 888888888 88   88

88888888  88 88     88 88    888888

88  88  88   888    88888    888888

88  88  88  88 88   88  88  88

88 8888 88 88   88  88888    8888

 888  888 888888888 88  88      88

  88  88  88     88 88   88888888""")

BJ_10172 개 (Bronze V) 

print('''|\\_/|

|q p|   /}

( 0 )"""\\

|"^"`    |

||_/=\\\\__|''')

BJ_10171 고양이 (Bronze V) 

print("""\    /\\

 )  ( ')

(  /  )

 \\(__)|""")

BJ_5339 콜센터 (Bronze V)

print("""     /~\\

    ( oo|

    _\\=/_

   /  _  \\

  //|/.\\|\\\\

 ||  \\ /  ||

============

|          |

|          |

|          |""")

BJ_5337 웰컴 (Bronze V) 

print(""".  .   .

|  | _ | _. _ ._ _  _

|/\\|(/.|(_.(_)[ | )(/.""")

BJ_9654 나부 함대 데이터 (Bronze V) 

print("""SHIP NAME      CLASS          DEPLOYMENT IN SERVICE

N2 Bomber      Heavy Fighter  Limited    21        

J-Type 327     Light Combat   Unlimited  1        

NX Cruiser     Medium Fighter Limited    18        

N1 Starfighter Medium Fighter Unlimited  25        

Royal Cruiser  Light Combat   Limited    4         """)

BJ_5338 마이크로소프트 로고 (Bronze V)

print("""       _.-;;-._

'-..-'|   ||   |

'-..-'|_.-;;-._|

'-..-'|   ||   |

'-..-'|_.-''-._|""")

BJ_10170 NFC West vs North (Bronze V)

print("""NFC West       W   L  T

-----------------------

Seattle        13  3  0

San Francisco  12  4  0

Arizona        10  6  0

St. Louis      7   9  0

NFC North      W   L  T

-----------------------

Green Bay      8   7  1

Chicago        8   8  0

Detroit        7   9  0

Minnesota      5  10  1

""")

[2] Input

Type | Input

KIM_06 입력하기 

KIM_07 변수와 변수이름

KIM_08 숫자형, 문자열

KIM_10 자료형 변환하기

KIM_12 문자열 

1                                        # int

1.5                                        # float

"A"                                        # str

21CE_Type|Input(edit)

21CE_Type|Input

print(type(123))

print(type("abcde"))

print(type(12.3))

print(type("12345"))

print(type(123.0))

print(type([1,2,3]))

print(type(True))

print(type(['a', 'b', 'c']))

print(type(12 + 12.3))

print(type("abcde" * 2))

input()                                        # Always string

a = int(input())                                # convert to string

int(4 ** 0.5)                                # 2 (float → int)

int(2.6)                                        # 2 (float → int)

float(1)                                        # 1.0

print(int("1") + int("1"))                        # 2

21CH_Type|Input(edit)

21CH_Type|Input

print(type(input())) # input : abc

print(type(float(input()))) # input : 25.5

print(type(float(input()))) # input : 25.5

a = input().split(); print(type(a)) # input : 2 3

a, b, c = input().split(); print(type(b)) # input : 1 2 3

h, i = input().split(); print(type(h)) # input : ab cd

j, k = map(float, input().split()); print(type(k)) # input : 1.2 3.3

print(type(int(input()))) # input : 1234

print(type(input())) # input : hello

print(type(float(input()))) # input : 1234.5

o, p = map(int, input()); print(type(o)) # 12

Add | Subtract

Adding and subtracting negative numbers

Subtracting a negative = adding a positive 

How to solve one-step equation

22CE_add|subtract (edit) 

22CE_add|subtract

a= 'Python'

b= 'World'

print('xxx')

print(float(3))

print(hello)

print('sun'+"flower")

print(a+b)

print(b+5)

print('a+b')

print(int(3.9)+float(4))

print(int(a))

print(a+'3')

BJ_5522 카드 게임 (Bronze V) 

a = int(input())

b = int(input())

c = int(input())

d = int(input())

e = int(input())

print((a + b + c + d + e))

BJ_1000 A+B (Bronze V)

BJ_15740 A+B - 9 (Bronze V) 

a, b = map(int, input().split())

print(a + b)

BJ_11382 꼬마 정민 (Bronze V) 

a, b, c = map(int, input().split())

print(a + b + c)

BJ_2558 A+B - 2 (Bronze V) 

a = int(input())

b = int(input())

print(a + b)

BJE_13985 Equality (Bronze IV)

st = input().split()

if int(st[0]) + int(st[2]) == int(st[4]):

    print('YES')

else:

    print('NO')

BJ_10824 네 수 (Bronze III) 

a, b, c, d = input().split()

print(int(a + b) + int(c + d))

        

22ME_Add|Subtract (edit) 

22ME_Add|Subtract

24 + 9

        26 - 8

42 + 7

39 + 17

43 - 26

        117 + 19

192 - 15

        174 + 81

        205 + 87

314 - 67

22MH_add|subtract (edit) 

22MH_add|subtract

x+5=23

x-5=12

6+x=92

-5+x=40

x+4=10

x-14=-4

x-(-11)=15

x+24=45

x-54=123

2+x=10+2x

BJ_1001 A - B (Bronze V) 

a, b = map(int, input().split())

print(a - b)

BJ_16430 제리와 톰 (Bronze V)

a, b = map(int, input().split())

print(b - a, b)

BJ_18108 1998년생인 내가 (Bronze V)

print(int(input()) - 543)

BJ_3003 킹, 퀸, 룩 (Bronze V)

a, b, c, d, e, f = map(int, input().split())

print(1 - a, 1 - b, 2 - c, 2 - d, 2 - e, 8 - f)

BJ_16394 홍익대학교 (Bronze V)

a = int(input())

print(a-1946)

KT_simpleaddition (1.9) 

첫 줄에 a, 둘째 줄에 b가 주어진다. a + b 를 출력하라.

a = int(input())

b = int(input())

print(a + b)

        

KT_bijele (1.3) 

체스에는 킹, 퀸은 1개, 룩, 비숍, 나이트는 2개, 폰은 8개가 있다.

다음 줄에 킹, 퀸, 룩, 비숍, 나이트, 폰의 개수가 주어질 때, 더 필요한 개수를 한줄로 각각 출력하라. (빼야 한다면 -)

ex)

input

2 1 2 2 2 7

        output

-1 0 0 0 0 1

a, b, c, d, e, f = map(int, input().split())

print(1 - a, 1 - b, 2 - c, 2 - d, 2 - e, 8 - f)

Multiply | Variable

        

        KIM_33 문자열 연산자

23ME_Multiply|variable (edit) 

23ME_Multiply|variable 

5*7

0*2

231*3

각 상자에 5개의 연필이 있을때, 6상자에 담긴 총 연필 개수

23*4

9*5

-2*-2

7*3

3*9

2*2*4

23MH_Multiply | Variable(edit)

23MH_Multiply|variable

3 × 5 × 6

7 × 9 × 3

6 × 5 × 2

8 × 4 × 9

7 × 7 × 7

6 × 8 × 9

2 × 4 × 6

6 × 8 × 7

8 × 8 × 7

6 × 9 × 2

Basic Multiplication

Multiplication 2: The multiplication tables 

Why a negative times a negative is a positive 

        Why a negative times a negative makes intuitive sense 

        

#

                                                # Times 0 is 0

                                        # Distributive property

                                        # Thus answer is -3

Order of operation 

Order of operations example

print(2 * 2)                                                # 4

print('5' * ‘5’)                                                 # Error

        print('5' * 5)                                                 # 55555

print(2 + 2 * 2)                                                # 6

print((2 + 2) * 2)                                        # 8

23CE_multiply|variable (edit)

23CE_multiply|variable

a += 2; print(a)

print(a + 5)

a -= 3; print(a)

print(a + 3);

a -= 3; print(a)

print(a * 5);

a = 3 + a * 2; print(a)

a -= 3 + a; print(a)

print(a - 2);

a *= 3; print(a)

 

23CH_multiply|variable (edit) 

23CH_multiply|variable

a = 0

print(a); a *= 2                # 0

print(a); a += 1        # 0

print(a); a -= 3                # 1

print(a + 3);                # 1

print(a); a -= 3                # -2

print(a * 5);                # -25

print(a); a = 3 + a * 2        # -7

print(a); a -= 3 + a        # -7

print(a - 2);                # -5

print(a); a *= 3                # -3

BJ  10998 A×B (Bronze V)

a, b = map(int, input().split())

print(a * b)

BJ_13277 큰 수 곱셈 (Bronze V) 

a, b = map(int, input().split())

print(a * b)

BJ_15894 수학은 체육 (Bronze V)

a = int(input())

print(a * 4)

BJ_2338 긴자리 계산 (Bronze V) 

a = int(input())

b = int(input())

print(a + b)

print(a - b)

print(a * b)

BJ_15964 이상한 기호 (Bronze V) 

a, b = map(int, input().split())

print((a+b)*(a-b))

BJ_3046 R2 (Bronze V) 

a, b = map(int, input().split())

print((2 * b) - a)

BJ_2845 파티가 끝나고 난 뒤 (Bronze V)

w, h = map(int, input().split())

a, b, c, d, e = map(int, input().split())

r = w * h

print(a - r, b - r, c - r, d - r, e - r)

BJ_2914 저작권 (Bronze V) 

x, y = map(int, input().split())

print(x * (y - 1) + 1)

BJ_2163 초콜릿 자르기 (Bronze III)

a, b = map(int, input().split())

print(a * b - 1)

R2 

a, b, c 는 모두 정수이다.

(a + c) / 2 = b 이다.

a, b가 주어졌을때 c의 값을 구하여라.

a, b = map(int, input().split())

print((2 * b) - a)

KT_Faktor (1.3) 

a, b, c 는 모두 정수이다.

ceil(c / a) = b 이다.                        ⇒ ceil(1) = 1, ceil(1.1) = 2, ceil(0.9) = 1

a, b가 주어졌을때 c의 최솟값을 구하여라.

a, b = map(int, input().split())

print((b - 1) * a + 1)

Quotient | Remainder | Division

        

KIM_32 %로 홀짝 구분하기

Introduction to division with partial quotients

Introduction to remainders

Dividing numbers: intro to long division

Solving two-step equations 

Two-variable linear equations and their graphs 

print(24 // 5)                                                # 4

print(-5 % 3)                                                # 1

print(5 % 2)                                                # 1

        print(5.1 % 1)                                                # 0.1

24ME_quotient|remainder (edit) 

24ME_quotient|remainder

x - 4 = 9

x * 3 = 18

x // 7 = 14

x + 15 = -9

x * (-2) = -6

x // 4 - 6 = 13

x*9 +13 = -5

99 - x * 3 = 42

78 + x // 4 = 54

100 + x * (6 - 9) = 1

        BJ_10869 사칙연산 (Bronze V) 

a, b = map(int, input().split())

print(a+b,a-b,a*b,a//b,a%b,sep='\n')

        

BJ_15727 조별과제 (Bronze V) 

a = int(input())

print((a + 4) // 5)

BJ_17256 달달함이 넘쳐흘러 (Bronze V) 

ax, ay, az = map(int, input().split())

cx, cy, cz = map(int, input().split())

print(cx - az, cy // ay, cz - ax)

BJ_17496 스타후르츠 (Bronze V) 

n,t,c,p=map(int,input().split())

print((n-1)//t*c*p)

BJ_14924 폰 노이만과 파리 (Bronze IV)

a, b, c = map(int, input().split())

print(c // (a * 2) * b)

BJ_15700 타일 채우기 (Bronze IV)

a, b = map(int, input().split())

print(a * b // 2)

BJ_3004 체스판 조각 (Bronze IV) 

n = int(input())

print((n // 2 + 1) * (n - n // 2 + 1))

        

savingforretirement 

Alice 는 은퇴 후에 Bob 보다 돈이 많았으면 좋겠다.

첫줄에 Bob이 일을 시작 하는 나이, 은퇴하는 나이, 연봉, Alice가 일을 시작하는 나이, Alice의 연봉이 주어진다.

이 때 Alice가 은퇴를 해야되는 나이를 출력하라.

a, b, c, d, e = map(int, input().split())

print(d + (b - a) * c // e + 1)

        24CE_Quotient | Remainder(edit)

        24CE_Quotient | Remainder

print(1 // 2)                 # 0

print(5 // 3)                 # 1

print(5 + 3 // 2)         # 6

print(0 // 0)                # ERROR

print((18 - 4) % 3)         # 3.0

print(2 // 2 * (2 + 2))         # 4

print(1 // 0)                 # ERROR

print(-6 // 3)                 # -2

print(-6 // -3)                 # 2

print(9999999 % 2)         # 1

24CH_quotient|remainder (edit)

24CH_quotient|remainder

print(119 // 17)

print((-98) // 7)

print(20 // 4 - 15)

print(1938 % 7)

print(119 % 17)

print((-98) % 7)

print(1004 % 11)

print(1938 // 7)

print((18 - 4) % 3)

print((6 + 109) // 5)

BJ_1271 엄청난 부자2 (Bronze V) 

a, b = map(int, input().split())

print(a // b)

print(a % b)

print(c // (a * 2) * b)

BJ_14928 큰 수 (Bronze V) 

a = int(input())

print(a % 20000303)

BJ_10430 나머지 (Bronze V)

A, B, C = map(int, input().split())

print((A + B) % C)

print((A % C + B % C) % C)

print(A * B % C)

print((A % C) * (B % C) % C)

BJ_5554 심부름 가는 길 (Bronze V) 

a = int(input())

        b = int(input())

        c = int(input())

        d = int(input())

        print((a + b + c + d) // 60)

        print((a + b + c + d) % 60)

BJ_14652 나는 행복합니다 (Bronze V)

a, b, c = map(int, input().split())

print(c // b, c % b)

BJ_2588 곱셈 (Bronze IV) 

a=int(input())

b=int(input())

print(a*(b%10),a*((b//10)%10),a*(b//100),a*b)

BJ_2525 오븐 시계 (Bronze IV) 

        a, b = map(int, input().split())

c = int(input())

m = (a * 60 + b + c) % 1440

print(m // 60, m % 60)

BJ_2530 인공지능 시계 (Bronze IV) 

h, m, s = map(int, input().split())

total = h * 3600 + m * 60 + s + int(input())

print(total % (24 * 3600) // 3600, total % 3600 // 60, total % 60)

KIM_31 산술 연산자

The idea of division

Examples relating multiplication to division

Unknowns with multiplication and division 

Q.

Q.

Q.

        

Dividing positive and negative numbers

Unknowns with multiplication and division

        

Why dividing by zero is undefined 

Q.

Dividing positive and negative numbers

Q. Negative division

        

Comparing fractions 

Improper Fraction 

Adding fractions with unlike denominators

Adding mixed numbers 

25ME_division|format (edit) 

25ME_division|format

52+x=134

y-14=-6

x*34=17

12*x=144

x/7=20

-4/x=2

2*3*x=30

x-21=12

-9*x=81

34*x=0

BJ_16648 Accumulator Battery (Bronze IV) 

t,p=map(int,input().split())

p+=min(20,p)

print(t*p/(120-p))

romans   

1 마일은 1000 * 5280 / 4854 페이스이다. 마일이 주어졌을 때 페이스를 출력하라. (소수점은 반올림 한다)

n = float(input())

print(int(n * 5280000/4854 + 0.5))

[3] Conditional

Operators | Unicode

Comparing whole numbers

KIM_34 비교 연산자

31CE_Operators|Unicode (edit) 

31CE_Operators|Unicode

print(2 > 3)

print(-7 >= -6)

print(-15 < -13)

print("AAA" == "AAAA")

print(43 != 431)

print("a" < "b")

print("abcd" < "zyxw")

print("ab" <= "bc")

print("9999" > "10000")

print("2a5a" <= "2b5a")

31CH_Operators|Unicode(edit)

31CH_Operators|Unicode

print(ord('B')-ord('A'))

print(ord('z')-ord('A'))

print(ord('z')-ord('a'))

print(ord('v')-ord('e'))

print(chr(ord('C')+32))

print(chr(ord('a')+10))

print(ord('x')-ord('X'))

print(ord('R')-ord('q'))

print(chr(65+40))

print(chr(122-20))

BJ_11654 아스키 (Bronze V) 

print(ord(input()))

BJ_11283 한글2 (Bronze V) 

print(ord(input()) + 1 - ord("가"))

BJ_11282 한글 (Bronze IV) 

print(chr(ord('가') + int(input()) - 1))

BJ_13458 시험 감독 (Bronze II) 

a=[0]*26

for x in input():

    a[ord(x)-97]+=1

print(*a)

BJ_5622 다이얼 (Bronze II)

tel = input()

delay = 0

data = [3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,8,8,8,8,9,9,9,10,10,10,10]

for c in tel:

    delay += data[ord(c)-65]

print(delay)

BJ_5218 알파벳 거리 (Bronze II) 

for _ in range(int(input())):

    a, b = input().split()

    li = []

    for i in range(len(a)):

        li.append((ord(b[i])-ord(a[i]))%26)

    print("Distances:", *li)

BJ_5598 카이사르 암호 (Bronze II) 

st = input()

for ch in st:

    if ch <= 'C':

        print(chr(ord(ch) + 23), end='')

    else:

        print(chr(ord(ch) - 3), end='')

if, else | elif

KIM_37 If 

32CE_if|elif|else (edit) 

32CE_if|elif|else

a = 5

b = 3

print(1 if a == b else 2)

print(1 if a > b else 2)

print(1 if a == 4 and b == 3 else 2)

print(1 if a >= 0 or b < -1 else 2)

print(1 if all([a > 5, b < 5]) else 2)

print(1 if a > 10 else 2 if b < 10 else 3)

print(1 if len(a) == 1 else 2)

print(10 if a // b == 1 else 20)

print(1 if a % 2 == 0 else 2 if b % 2 ==0 else 3)

print(1 if ord('a') > a else 2 if ord('b') < b else 3)

BJ_17903 Counting Clauses (Bronze IV) 

a, b= map(int, input().split())

if a >= 8:

    print("satisfactory")

else:

    print("unsatisfactory")

BJ_15680 연세대학교 (Bronze IV)

a = int(input())

if a == 0:

    print('YONSEI')

else:

    print('Leading the Way to the Future')

print('YONSEI' if input() == '0' else 'Leading the Way to the Future')

BJ_16428 A/B - 3 (Bronze IV) 

a, b = map(int, input().split())

if b < 0:

    print(a // b + 1)

    print(a % b - b)

else:

    print(a // b)

    print(a % b)

BJ_1712 손익분기점 (Bronze IV) 

        A, B, C = map(int, input().split())

if C <= B:

    print(-1)

else:

    print(A // (C - B) + 1)

BJ_15963 CASIO (Bronze IV) 

a, b = map(int, input().split())

print(1 if a == b else 0)

a, b = map(int, input().split())

if a == b:

    print(1)

else:

    print(0)

        

BJ_14470 전자레인지 (Bronze IV) 

a, b, c, d, e = int(input()), int(input()), int(input()), int(input()), int(input())

if a > 0:

    print(e * (b - a))

else:

    print((-a * c) + d + e * b)

BJ_10162 전자레인지 (Bronze IV) 

n = int(input())

if n % 10 != 0:

    print(-1)

else:

    print(n // 300, n % 300 // 60, n % 60 // 10)    

BJE_6778 Which Alien? (Bronze IV) 

a, e = int(input()), int(input())

if a >= 3 and e <= 4:

    print('TroyMartian')

if a <= 6 and e >= 2:

    print('VladSaturnian')

if a <= 2 and e <= 3:

    print('GraemeMercurian')

BJ_14038 Tournament Selection (Bronze IV) 

w = 0

for _ in range(6):

    if input() == 'W':

        w += 1

if w == 0:

    print(-1)

elif w <= 2:

    print(3)

elif w <= 4:

    print(2)

else:

    print(1)

BJE_15080 Every Second Count (Bronze IV) 

a, b, c = map(int, input().split(" : "))

d, e, f = map(int, input().split(" : "))

time = (d-a) * 3600 + (e - b) * 60 + f - c

if(time < 0):

    time += 24 * 3600

print(time)

BJE_17009 Winning Score (Bronze IV)

apple = banana = 0

apple += int(input()) * 3

apple += int(input()) * 2

apple += int(input())

banana += int(input()) * 3

banana += int(input()) * 2

banana += int(input())

if apple < banana:

    print('B')

elif apple == banana:

    print('T')

else:

    print('A')

BJ_2884 알람 시계 (Bronze III) 

h, m = map(int, input().split())

m = h * 60 + m - 45

if m < 0:

    m += 1440

print(m // 60, m % 60)

KIM_38 Else, elif 

BJ_1330 두 수 비교 (Bronze IV)

A, B = map(int, input().split())

if A > B:

    print('>')

elif A < B:

    print('<')

else:

    print('==')

         

BJ_9498 시험 성적 (Bronze IV)

score = int(input())

if score >= 90:

    print('A')

elif score >= 80:

    print('B')

elif score >= 70:

    print('C')

elif score >= 60:

    print('D')

else:

    print('F')

BJ_10101 삼각형 외우기 (Bronze IV) 

A = int(input())

B = int(input())

C = int(input())

if A + B + C != 180:

    print("Error")

elif A == B == C:

    print("Equilateral")

elif A == B or B == C or A == C:

    print("Isosceles")

else:

    print("Scalene")

BJ_19944 뉴비의 기준은 뭘까? (Bronze IV)

a, b = map(int, input().split())

if b < 3:

    print('NEWBIE!')

elif b <= a:

    print('OLDBIE!')

else:

    print('TLE!')

BJE_6764 Sounds Fishy! (Bronze IV) 

a=int(input())

b=int(input())

c=int(input())

d=int(input())

if a<b<c<d:print('Fish Rising')

elif a>b>c>d:print('Fish Diving')

elif a==b==c==d:print('Fish At Constant Depth')

else:print('No Fish')

BJ_2985 세 수 (Bronze III) 

a, b, c = map(int, input().split())

if a + b == c:

    print(f"{a}+{b}={c}")

elif a - b == c:

    print(f"{a}-{b}={c}")

elif a * b == c:

    print(f"{a}*{b}={c}")

elif a // b == c:

    print(f"{a}/{b}={c}")

elif a == b + c:

    print(f"{a}={b}+{c}")

elif a == b - c:

    print(f"{a}={b}-{c}")

elif a == b * c:

    print(f"{a}={b}*{c}")

elif a == b // c:

    print(f"{a}={b}/{c}")

KT_twostones (1.3) 

a개의 돌이 다음과 같이 1열로 나열되어 있다.

1 2 3 … a

Alice 와 Bob 이 번갈아 가며 2개의 연속된 번호의 돌을 가져간다.

더 이상 가져갈 수 있는 돌이 없을때, 남은 돌의 개수가 홀수이면 Alice가 이기고 짝수면 Bob이 이긴다.

예를들어 돌 1 2 3 4 로 시작해 Alice 가 2, 3 을 가져가면 Bob은 더 이상 가져갈 수 있는 연속된 돌이 없고,

남은 돌의 개수는 1, 4, 총 2개이므로 Bob이 승리한다.

Alice가 항상 먼저 시작 가져가고 두 명은 항상 최적의 수를 둔다.

a가 주어질때 승자를 구하여라.

[Simp] a 가 짝수이면 Bob 홀수이면 Alice를 출력하라.

# Alice와 Bob 이 2개를 여러번 가져가도 남은 돌의 개수의 parity(짝, 홀)은 변하지 않는다.

a = int(input())

if a % 2 == 1:

    print("Alice")

else:

    print("Bob")

Logical

논리 연산자

33CE_logical (edit) 

33CE_logical

a = 10

print(True and False)

print(True or False)

print( a % 2 == 0 )

print( a // 2 != 0 and a * 3 = 9 )

print( a == 9 or a == 10 )

print(all([True, False, False, True])

print(any([True, False, False, True]))

print(all([True, True, True False]))

print(all([True, any([False, True])]))

BJ_14681 사분면 고르기 (Bronze IV) 

a = int(input())

b = int(input())

if a > 0 and b > 0:

    print(1)

elif a < 0 and b > 0:

    print(2)

elif a < 0 and b < 0:

    print(3)

else:

    print(4)

BJ_17362 수학은 체육과목 입니다2 (Bronze IV) 

turn = int(input()) % 8

if turn == 1:

    print(1)

elif turn == 2 or turn == 0:

    print(2)

elif turn == 3 or turn == 7:

    print(3)

elif turn == 4 or turn == 6:

    print(4)

elif turn == 5:

    print(5)

BJ_17388 와글와글 숭고한 (Bronze IV) 

a, b, c = map(int, input().split())

if a + b + c >= 100:

    print("OK")

elif a < b and a < c:

    print("Soongsil")

elif b < a and b < c:

    print("Korea")

else:

    print("Hanyang")

BJ_2753 윤년 (Bronze IV) 

n = int(input())

if n % 4 == 0 and (n % 100 != 0 or n % 400 == 0):

    print(1)

else:

    print(0)

BJ_2480 주사위 세개 (Bronze IV) 

a, b, c = map(int, input().split())

if a == b == c:

    print(10000 + a * 1000)

elif a == b or a == c:

    print(1000 + a * 100)

elif b == c:

    print(1000 + c * 100)

else:

    print(max(a, b, c) * 100)

BJ_10768 특별한 날 (Bronze IV) 

m, d = int(input()), int(input())

if m == 1 or m == 2 and d < 18:

    print('Before')

elif m == 2 and d == 18:

    print('Special')

else:

    print('After')

BJ_4299 AFC 윔블던 (Bronze IV) 

sm, df = map(int, input().split())

a = sm - (sm + df) // 2

b = (sm + df) // 2

if (sm + df) % 2 != 0 or a < 0 or b < 0:

    print(-1)

elif a > b:

    print(a, b)

else:

    print(b, a)

Halloween

input 이 OCT 31 이거나 DEC 25 일 시 'yup' 그렇지 않으면 'nope' 를 출력한다

s = input()

if s == 'OCT 31' or s == 'DEC 25':

    print('yup')

else:

    print('nope')

min, max | abs

BJ_11943 파일 옮기기 (Bronze IV) 

a, b = map(int, input().split())

c, d = map(int, input().split())

print(min(a + d, b + c))

BJE_18330 Petrol (Bronze IV) 

cur, nex = int(input()), int(input())

print(min(cur, nex + 60) * 1500 + (cur - min(cur, nex + 60)) * 3000)

BJ_2480 주사위 세개 (Bronze IV) 

a, b, c = map(int, input().split())

if a == b == c:

    print(10000 + a * 1000)

elif a == b or a == c:

    print(1000 + a * 100)

elif b == c:

    print(1000 + c * 100)

else:

    print(max(a, b, c) * 100)

BJ_19698 헛간 청약 (Bronze IV)

n, w, h, l = map(int, input().split())

cow = (w // l) * (h // l)

print(min(cow, n))

BJ_10818 최소, 최대 (Bronze III)

_ = input()

li = list(map(int, input().split()))

print(min(li), max(li))

BJ_1085 직사각형에서 탈출 (Bronze III) 

x, y, w, h=map(int,input().split())

print(min(x, y, w - x, h -  y))

BJ_16917 양념 반 후라이드 반 (Bronze III) 

a, b, c, x, y = map(int, input().split())

v = 0

if x > y:

    v = 2 * c * y + a * (x - y)

else:

    v = 2 * c * x + b * (y - x)

print(min(a*x + b*y, 2 * c * max(x, y), v))

Absolute value of integers

34CE_min|max|abs (edit) 

34CE_min|max|abs

a = -5

b = 3

print(abs(a))

print(abs(a*b))

print(min(1,2,3,4,5))

print(min(-10, -5, 0, 5, 10))

print(max(a,b))

print(abs(min(a,b)))

print(max([6, -10, 1, 3]))

print(min('a, 'c',’e’))

print(min(True, False))

        BJ_2420 사파리 월드 (Bronze IV) 

a, b = map(int, input().split())

print(abs(a - b))

BJ_16204 카드뽑기 (Bronze IV) 

N, M, K = map(int, input().split())

print(min(M, K) + N - max(M, K))

BJ_15726 이칙연산 (Bronze IV) 

a, b, c = map(int, input().split())

print(max(a * b // c, int(a / b * c)))

print(max(a * b // c, a * c // b))

BJ_5596 시험 점수 (Bronze IV) 

a, b, c, d = map(int, input().split())

e, f, g, h = map(int, input().split())

print(max(a + b + c + d, e + f + g + h))

BJ_10039 평균 점수 (Bronze IV) 

a = max(40, int(input()))

b = max(40, int(input()))

c = max(40, int(input()))

d = max(40, int(input()))

e = max(40, int(input()))

sum = (a+b+c+d+e) // 5

print(sum)

        

BJ_11948 과목선택 (Bronze IV) 

a = int(input())

b = int(input())

c = int(input())

d = int(input())

e = int(input())

f = int(input())

print(a + b + c + d + e + f - min(a, b, c, d) - min(e, f))

BJ_10707 수도 요금 (Bronze IV) 

a = int(input())

b = int(input())

c = int(input())

d = int(input())

e = int(input())

X = a * e

Y = b + max(e - c, 0) * d

print(min(X, Y))

BJ_10156 과자 (Bronze IV) 

a, b, c = map(int, input().split())

print(max(0, a * b - c))

BJ_16431 베시와 데이지 (Bronze IV) 

a, b = map(int, input().split())

c, d = map(int, input().split())

e, f = map(int, input().split())

x = max(abs(e - a), abs(f - b))

y = abs(e - c) + abs(f - d)

if x == y:

    print('tie')

elif x < y:

    print('bessie')

else:

    print('daisy')

BJ_1598 꼬리를 무는 숫자 나열 (Bronze III) 

a, b = map(int, input().split())

a -= 1

b -= 1

print(abs(a // 4 - b // 4) + abs(a % 4 - b % 4))

BJ_2908 상수 (Bronze II) 

a, b = map(int, input().split())

ra = (a % 10) * 100 + (a // 10 % 10) * 10 + (a // 100)

rb = (b % 10) * 100 + (b // 10 % 10) * 10 + (b // 100)

print(max(ra, rb))

kattis_pieceofcake2 (1.3)

정수 a, b, c 가 주어진다. 한 변의 길이가 a이고 높이가 4인  정사각형의 케익이 있다.

가로로 b, 세로로 c의 위치에서 케익을 자른다. 이때 가장 큰 조각의 부피를 구해라.

a, b, c = map(int, input().split())

print(max(a - b, b) * max(a - c, c) * 4)

kattis_dicecup (1.3)

        두 주사위에 a와 b개의 면이 있다. 이때 두 주사위를 굴렸을 때 가장 높은 확률로 나오는 합을 출력하라.

a, b = map(int, input().split())

for i in range(min(a, b) + 1, max(a, b) + 2):

    print(i)

judgingmoose

왼쪽과 오른쪽의 뿔의 개수가 주어진다.

왼쪽과 오른쪽의 뿔의 개수가 같을 때                 → Even 총_뿔수

다를 시                                                 → Odd 더_많은_뿔수 * 2

뿔이 하나도 없을 시                                 → Not a Moose를 출력한다.

a, b = map(int, input().split())

if a == b == 0:

    print("not a moose")

elif a == b:

    print(f"Even {a * 2}")

else:

    print(f"Odd {max(a, b) * 2}")

        

somesum

1부터 100까지 연속된 n개의 수를 뽑는다.

이 때 수의 합이 짝수이면 Even 홀수이면, Odd, 둘다 가능하면 Either을 출력하라.

n = int(input())

if n % 4 == 0:

    print('Even')

elif n % 2 == 0:

    print('Odd')    

else:

    print('Either')

moscowdream

첫줄에 a, b, c, d가 주어진다.

이는 각각 easy, medium, hard, total문제 개수 이다.

easy, medium, hard를 모두 포함하고, 총 문제 수가 total인 문제집을 만들 수 있으면 YES 아니면 NO를 출력하라.

a, b, c, d = map(int, input().split())

if a == 0 or b == 0 or c == 0 or a + b + c < d or d < 3:

    print("NO")

else:

    print("YES")

filip 

a, b는 0이 포함되지 않은 3자리 정수이다.

a, b 의 숫자를 뒤집었을 때,                         ⇒ 426 를 뒤집으면 624

뒤집혀진 a, b중 큰 수를 구하라.

a, b = map(int, input().split())

ra = (a % 10) * 100 + (a // 10 % 10) * 10 + (a // 100)

rb = (b % 10) * 100 + (b // 10 % 10) * 10 + (b // 100)

print(max(ra, rb))

onechicken

a, b가 주어진다.

a 가 b 보다 크면 Dr. Chaz needs a - b more pieces of chicken!

b 가 a 보다 크면 Dr. Chaz will have b - a pieces of chicken left over!

를 출력하라. (이 때 차이가 1이면 s는 pieces를 piece로 대체한다.)

a, b = map(int, input().split())

if a < b:

    print(f"Dr. Chaz will have {b - a} piece{'' if b - a == 1 else 's'} of chicken left over!")

else:

    print(f"Dr. Chaz needs {a - b} more piece{'' if a - b == 1 else 's'} of chicken!")

quadrant 

a, b는 0이 아닌 정수이다.

a, b가 주어졌을때 몇 사분면(Quadrant)에 있는지 구하여라.

        a = int(input())

b = int(input())

if a > 0 and b > 0:

    print(1)

elif a < 0 and b > 0:

    print(2)

elif a < 0 and b < 0:

    print(3)

else:

    print(4)

spavanac

아침에 일찍 일어나고자 알람을 45분 일찍 맞춘다.

h, m이 주어지면 맞춰야 되는 알람시간 h, m을 출력하라.

h, m = map(int, input().split())

total = h * 60 + m - 45

if total < 0:

    total += 1440

print(total // 60, total % 60)

railroad2 

a와 b가 주어진다.

b가 짝수이면 possible 홀수이면 impossible을 출력한다.

a, b = map(int, input().split())

if b % 2 == 0:

    print("possible")

else:

    print("impossible")

datum

정수 m, d가 주어진다.

2009년 m월 d일이 무슨 요일인지 출력하라.

n_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

weeks = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

day, month = map(int, input().split())

nth = sum(n_days[:month - 1]) + day - 1

print(weeks[(nth + 3) % 7])

provincesandgold 

골드는 3, 실버는 2, 쿠퍼는 1의 값어치를 한다.

한 턴에 victory 카드와 treasure 카드 중 하나를 선택 할 수 있는데 비용은 아래와 같다.

Province (costs 8)

Duchy (costs 5)

Estate (costs 2)

Gold (costs 6)

Silver (costs 3)

Copper (costs 0)

골드 실버 쿠퍼의 개수가 주어질 때 고를 수 있는 최고의 victory or treasure 카드를 출력하라.

g, s, c = map(int, input().split())

tot = g * 3 + s * 2 + c

if tot >= 8:

    print("Province or Gold")

elif tot >= 6:

    print("Duchy or Gold")

elif tot >= 5:

    print("Duchy or Silver")

elif tot >= 3:

    print("Estate or Silver")

elif tot >= 2:

    print("Estate or Copper")

else:

    print("Copper")

[4] Loop | Iterables

split, map | builtins

input().split()                                        # 띄어쓰기를 기준으로 나눔

a, b = map(int, input().split())                        # 모두 숫자형으로 바꿈

Map object must be casted → to save memory

        

li = [1, 2, 3, 4]

def double(n):

    return n * 2

        list(map(lambda x : x * x, numbers))                # lambda function

        41CE_split|map (edit) 

41CE_split|map

a = ['1', '2', '3']

b = "5"

c = '5 10 15 20'

print(c.split())

print(c.split('0'))

print('Python'+int(b))

print(a+b)

print(b+5)

print(list(map(int, c.split())))

print(sum(map(int, a)))

print(list(map(float, a)))

print(list(map(int, a))[1])

print(list(map(int, b)))

carrots 

첫 줄에 a, b가 주어진다.

b를 출력하라.

_, a = map(int, input().split())

print(a)

skocimis 

캥거루 a, b, c가 한 선 위에 순서대로 있다.

캥거루 a, c가 b 양옆으로 점프를 하는데, 이 때 더 긴 점프의 길이를 출력하라.

a, b, c = map(int, input().split())

print(max(c - b - 1, b - a - 1))

nodup 

문장이 주어지는데, 문장에서 같은 단어가 두번 이상 등장하면 no 모든 단어가 한번 등장하면 yes를 출력하라.

li = input().split()

print("yes" if len(set(li)) == len(li) else "no")

len                                                # find length of iterable

sum                                                # sum of all iterables

BJ_15873 공백 없는 A+B (Bronze IV) 

s = input()

if len(s) == 4:

    print(20)

elif len(s) == 3:

    if s[1] == '0'

        print(10 + int(s[2]))

    else:

        print(10 + int(s[0]))

else:

    print(int(s[0]) + int(s[1]))

BJ 11023 더하기 3 (Bronze III) 

n = list(map(int, input().split()))

print(sum(n))

BJ_11024 더하기 4 (Bronze III) 

N = int(input())

for _ in range(N):

    n = list(map(int, input().split()))

    print(sum(n))

BJ_10822 더하기 (Bronze II) 

print(sum(map(int, input().split(','))))

BJ_1152 단어의 개수 (Bronze II)

li = list(input().split())

print(len(li))

        

BJ_11720 숫자의 합 (Bronze II)

input()

print(sum(map(int, input())))

BJ_15596 정수 N개의 합 (Bronze II) 

def solve(a):

    return sum(a)

BJ_4999 아! (Bronze II) 

a = input()

b = input()

if len(b) > len(a):

    print("no")

else:

    print('go')

BJ_1546 평균 (Bronze I) 

n = int(input())

li = list(map(int, input().split()))

print(sum(li) / max(li) * 100 / len(li))

BJ_10769 행복한지 슬픈지 (Bronze I) 

s = input()

happy = s.count(":-)")

sad = s.count(":-(")

if happy < sad:

    print("sad")

elif happy > sad:

    print("happy")

elif happy == sad != 0:

    print("unsure")

else:

    print("none")

aaah 

두 문자가 각 줄에 주어진다.

이 때 첫 문자가 길면 no 두번째 길이가 같거나, 두번째 문자가 길 때는 go를 출력하라.

a = input()

b = input()

if len(b) > len(a):

    print("no")

else:

    print('go')

LC151_ reverse-words-in-a-string

def reverseWords(self, s: str) -> str:

    return " ".join(reversed(s.split()))

 range | for | enumerate

KIM_27 range() 

42CE_range|for (edit) 

42CE_range|for

print(range(10)[2])

print(range(-10)[2])

print(range(30)[30])

print(range(10,100)[2])

print(range(-10,-100)[2])

print(range(10, 2)[1])

print(range(3,5,2)[1])

print(range(0,100,3)[10])

print(range(100,0,-10)[5])

print(range(0,-1000,10)[10])

42CH_range|for (edit) 

42CH_range|for 

for i in range(3):    

    print(1, end = ' ')

for i in range(5):

    print(i, end = ' ')

for i in range(1,6,2):

    print(i, end = ' ')

for i in range(5,16,4):

    print(i, end = ' ')

for i in range(10, 0, -2):

    print(i, end = ' ')

for i in range(0, 10, 10):  

    print(i, end = ' ')

for i in range(0, 10, 0):  

    print(i, end = ' ')

for n in range(1, 10, 2):    

    print(n, end = ' ')

for i in range(10, 0, -1):

    print(i, end = ' ')

for i in range(0, 10, 0.5):

    print(i, end = ' ')

BJ 2742 기찍 N (Bronze III)

for i in range(int(input()), 0, -1):

    print(i)

BJ_2739 구구단 (Bronze III) 

a = int(input())

for i in range(1, 10):

    print(f"{a} * {i} = {a * i}")

BJ 13752 히스토그램 (Bronze III) 

N = int(input())

for _ in range(N):

    print('=' * int(input()))

BJ_2438 별찍기 (Bronze III) 

n = int(input())

for i in range(1, n + 1):

    print('*' * i)

BJ_2439 별찍기2 (Bronze III) 

n = int(input())

for i in range(1, n + 1):

    print(' ' * (n - i) + '*' * i)

BJ_2440 별찍기3 (Bronze III) 

a = int(input())

for i in range(1,a+1):

    print("*"*(a-i+1))

BJ_2441 별찍기4 (Bronze III) 

a = int(input())

for i in range(1,a+1):

    print(" "*(i-1) + "*"*(a-i+1))

BJ_2442 별찍기5 (Bronze III) 

a = int(input())

for i in range(1,a+1):

    b = ' '*(a-i)+'*'*((2*i)-1)

    print(b)

BJ_2443 별찍기6 (Bronze III) 

a = int(input())

for i in range(a-1,-1,-1):

    print(' '*(a-i-1)+('*'*(2*i+1)))

BJ_2444 별찍기7 (Bronze III) 

a = int(input())

for i in range(a-1):

    print(' '*(a-i-1)+('*'*(2*i+1)))

for i in range(a-1,-1,-1):

    print(' '*(a-i-1)+('*'*(2*i+1)))

BJ_2445 별찍기8 (Bronze III) 

a=int(input())

b=a

for i in range(1,a+1):

    print('*'*(i)+' '*(2*(b-i))+'*'*(i))

for k in range(1,b+1):

    print('*'*(b-k)+' '*(2*k)+'*'*(b-k))

BJ_2446 별찍기9 (Bronze III) 

a = int(input())

for i in range(a-1,0,-1):

    print(' '*(a-i-1)+('*'*(2*i+1)))

for i in range(a):

    print(' '*(a-i-1)+('*'*(2*i+1)))

BJ_2522 별찍기12 (Bronze III) 

a = int(input())

b = a

for i in range(1, a+1):

    print(' '*(b-i)+'*'*(i))

for k in range(1,b):

    print(' '*(k)+'*'*(b-k))

BJ_10990 별 찍기 - 15 (Bronze III) 

N = int(input()) - 1

print (" " * N + "*")

for i in range(N):

    print(" " * (N - i - 1) + '*' + ' ' * (i * 2 + 1) + '*')

BJ_10991 별찍기 16 (Bronze III) 

a = int(input())

for i in range(1, a + 1):

    print(' ' * (a - i) + '* ' * i)

BJ_5354 J박스(Bronze III)

for _ in range(int(input())):

    a = int(input())

    print("#" * a)

    for _ in range(a - 2):

        print("#" + "J" * (a - 2) + "#")

    if a > 1:

        print("#" * a)

    print()

BJ_10995 별 찍기 - 20 (Bronze II) 

n = int(input())

for i in range(n):

    print("* " * n if i % 2 == 0 else " *" * n)

BJ_10996 별 찍기21(Bronze II) 

n = int(input())

for _ in range(n):

    print('* ' * (n - n//2))

    print(' *' * (n//2))

        BJ_10950 A + B - 3 (Bronze III) 

        for _ in range(int(input())):

    a, b = map(int, input().split())

    print(a + b)

BJ_10569 다면체 (Bronze III)

T = int(input())

for _ in range(T):

    V, E = map(int, input().split())

    print(2 - V + E)

        BJ_11006 남욱이의 닭장 (Bronze III)

for _ in range(int(input())):

    a, b = map(int, input().split())

    print((b * 2 - a), (a - b))

BJ_10214 Baseball (Bronze III)

for _ in range(int(input())):

    yonsei = korea = 0

    for _ in range(9):

        a, b = map(int, input().split())

        yonsei += a

        korea += b

    if yonsei > korea:

        print('Yonsei')

    elif yonsei == korea:

        print('Draw')

    else:

        print('Korea')

BJ_3028 창영마을 (Bronze III)

moves = input()

cur = 1

for move in moves:

    if move == 'A':

        if cur == 1:

            cur = 2

        elif cur == 2:

            cur = 1    

    elif move == 'B':

        if cur == 2:

            cur = 3

        elif cur == 3:

            cur = 2

    else:

        if cur == 1:

            cur = 3        

        elif cur == 3:

            cur = 1    

print(cur)

BJ 18883 NM 찍기 (Bronze III) 

n, m = map(int, input().split())

num = 0

for i in range(n):

    for j in range(m):

        num += 1

        if j == m - 1:

            print(num)

        else:

            print(num, end=' ')

        BJ_8320 직사각형을 만드는 방법 (Bronze III) 

n = int(input())

cnt = 0

for i in range(1, n + 1):

    for j in range(i, n + 1):

        if i * j <= n:

            cnt += 1

print(cnt)

BJ_2010 플러그 (Bronze III) 

n = int(input())

total = 0

for _ in range(n):

    total += int(input())

print(total - n + 1) 

BJ_2490 윷놀이 (Bronze III) 

for i in range(3):

    s = sum(int, input().split())

    if s == 0:

        print('D')

    elif s == 1:

        print('C')

    elif s == 2:

        print('B')

    elif s == 3:

        print('A')

    else:

        print('E')

BJ_9085 더하기 (Bronze III) 

for _ in range(int(input())):

    m = int(input())

    print(sum(map(int, input().split())))

BJ_10103 주사위 게임(Bronze III) 

c = s = 100

for _ in range(int(input())):

    first, second = map(int, input().split())

    if first < second:

        c -= second

    elif first > second:

        s -= first

print(c, s, sep='\n')

BJ_2455 지능형 기차 (Bronze III) 

cur = 0

m = 0

for i in range(4):

    a, b = map(int, input().split())

    total += b - a

    if m < cur:

        m = cur

print(m)

BJ_2460 지능형 기차2 (Bronze III) 

mx, cur = 0, 0

for _ in range(10):

    leave, enter = map(int, input().split())

    cur = cur - leave + enter

    if mx < cur:

        mx = cur

print(mx)

BJ_1547 공 (Bronze III) 

n = int(input())

cur = 1

for _ in range(n):

    a, b = map(int, input().split())

    if cur == a:

        cur = b

    elif cur == b:

        cur = a

print(cur)

BJ_10872 팩토리얼 (Bronze III) 

k= int(input())

ret=1

for i in range(1,k+1):

    ret = ret*i

print(ret)

BJ_5565 영수증 (Bronze III) 

a = int(input())

for _ in range(9):

    a -= int(input())

print(a)  

        

BJ_2576 홀수 (Bronze III) 

sm = 0

mn = 100

for _ in range(7):

    a = int(input())

    if a % 2 == 1:

        mn = min(mn, a)

        sm += a

if mn == 100:

    print(-1)

else:

    print(sm)        

    print(mn)

BJ_10886 0 = not cute / 1  (Bronze III) 

a=int(input())

b=0

for i in range(a):

    b=b+int(input())

if b>(a//2):

    print("Junhee is cute!")

else:

    print("Junhee is not cute!")

BJ_2953 나는 요리사다 (Bronze III)   

num = mx = 0

for i in range(5):

    temp = sum(map(int, input().split()))

    if (mx < temp):

        mx = temp

        num = i + 1;

       

print(num, mx)

BJ_10250 ACM 호텔 (Bronze III) 

for _ in range(int(input())):

    h,w,n = map(int,input().split())

    print(str((n-1)%h+1) + str((n-1)//h+1).rjust(2, '0'))

BJ_2547 사탕 선생 고창영 (Bronze III) 

N = int(input())

li = [int(input()) for _ in range(N)]

for m in li:

    for t in [25, 10, 5, 1]:

        print(m // t, end = ' ')

        m %= t

    print()

BJ_2476 주사위 게임 (Bronze III)

mx = 0

for _ in range(int(input())):

    a, b, c = map(int, input().split())

    if a == b == c:

        mx = max(mx, 10000 + a * 1000)

    elif a == b or a == c:

        mx = max(mx, 1000 + a * 100)

    elif b == c :

        mx = max(mx, 1000 + b * 100)

    else:

        mx = max(mx, max(a, b, c) * 100)

print(mx)

BJ_11134 쿠키 애호가 (Bronze III)

for _ in range(int(input())):

    n, c = map(int, input().split())

    print((n - 1)//c + 1)

BJ_1225 이상한 (Bronze II)

A, B = map(str, input().split())

digit_A = 0

digit_B = 0

for a in A:

    digit_A += int(a)

for b in B:

    digit_B += int(b)

print(digit_A * digit_B)

BJ_10953  A+B - 6 (Bronze II) 

N = int(input())

for _ in range(N):

    a, b = map(int, input().split(','))

    print(a + b)

BJ_5988 Even Odd (Bronze II) 

N = int(input())

for _ in range(N):

    if int(input()) % 2 == 0:

        print("even")

    else:

        print("odd")

BJ_8958 OX 퀴즈 (Bronze II) 

N = int(input())

for _ in range(N):

    st = input()

    score, row = 0, 0

    for ch in st:

        if ch == 'X':

            row = 0

        else:

            row += 1

            score += row

    print(score)

BJ_9625 BABBA (Bronze I)

a, b = 1, 0

for i in range(int(input())):

    a, b = b, a + b

print(a, b)

        

BJ_1205 등수 구하기 (Silver IV)

N, score, p = map(int, input().split())

if N == 0:

    print(1)

    exit()

li = list(map(int, input().split()))

if len(li) >= p and li[p - 1] >= score:

    print(-1)

else:

    li += [-1]

    for i in range(p):

        if li[i] <= score:

            print(i + 1)

            break

KT_Heartrate (1.3)

첫줄에 N이 주어지고 N줄에 b,p가 차례로 주어진다

ABPM최솟값, BPM값, ABPM최댓값을 한 줄에 출력하라.

(BPM은 60b/p로 계산)

n_test = int(input())

for _ in range(n_test):

    beat, sec = map(float, input().split())

    print((beat - 1) / sec * 60, beat / sec * 60, (beat + 1) / sec * 60)

trik (1.4) 

처음에는 1번에 구슬이 놓여있고 ABC는 위와 같이 정의 된다.

주어진 인풋과 같이 돌을 옮겼을때 최종적인 돌의 위치를 출력하라.

moves = input()

cur = 1

for move in moves:

    if move == 'A':

        if cur == 1:

            cur = 2

        elif cur == 2:

            cur = 1    

    elif move == 'B':

        if cur == 2:

            cur = 3

        elif cur == 3:

            cur = 2

    else:

        if cur == 1:

            cur = 3        

        elif cur == 3:

            cur = 1    

print(cur)

KT_jobexpenses (1.4) 

첫줄에 N이 주어진다.

다음 줄에 N개의 숫자가 주어지는데, 이 때 0보다 작은 수의 절대값의 합을 구하여라.

N = int(input())

ret = 0

for a in map(int, input().split()):

    if a < 0:

        ret -= a

print(ret)

KT_Tai's formula (1.5) 

pa, pb = None, None

ret = 0

for _ in range(int(input())):

    a, b = map(float, input().split())

    if pa != None:

        ret += (a - pa) * (b + pb) / 2 / 1000

    pa, pb = a, b

print(ret)

KT_sibice (1.6)

첫 줄에 N, w, h이 주어진다.

다음 N줄에 성냥의 길이가 주어지는데 이때 가로 세로가 w, h 인 상자에 들어가면 DA, 들어가지 않으면 DE를 출력하라.

n_match, w, h = map(int, input().split())

mx = (w ** 2 + h ** 2) ** 0.5

for _ in range(n_match):

    x = int(input())

    if x <= mx:

        print('DA')

    else:

        print('NE')

BJ_14656 조교는 새디스트야!! (Bronze III)

n = int(input())

students = list(map(int, input().split()))

res = 0

for i, s in enumerate(students):

    if s != i + 1:

        res += 1

print(res)

KT_conundrum (1.4)

주어진 문자를 PERPERPER로 바꾸는데 몇 번 문자를 바꿔야 하는가?

st = input()

ret = 0

for i, ch in enumerate(st):

    if i % 3 == 0 and ch != 'P':

        ret+=1

    if i % 3 == 1 and ch != 'E':

        ret+=1

    if i % 3 == 2 and ch != 'R':

        ret+=1

print(ret)

Index, Slice

KIM_15 문자열 인덱싱

li = [1, 2, 0 6]

        li[i]                                                # element in ith index

KIM_16 문자열 슬라이싱 

KIM_22 리스트 인덱싱, 슬라이싱

a = "abcdefg"

print(a[:3])                                        # abc

43CE_index|slice (edit) 

43CE_index|slice

a = "abcde"

b = "zxyb"

print(a[0])

print(b[5])

print(a[2] + b[1])

print(b[0]*3)

print((a[1]+b[3])*2)

print(a[3],b[1])

print(a[:4])

print(b[2:])

print(b[-4])

print(a[:-3]+b[-2:])

BJE_17863 FYI (Bronze IV) 

a = input()

if a[:3] == "555":

    print("YES")

else:

    print("NO")

BJ_5543 상근날드 (Bronze IV)

p = list(map(int, input.split()))

print(min(p[:3]) + min(p[3:]) - 50)

BJ_9086 문자열 (Bronze II)

for _ in range(int(input())):

    s = input().rstrip()

    print(s[0], s[-1], sep='')

BJ_2711 오타맨 고창영 (Bronze II) 

for _ in range(int(input())):

    a, b = input().split()

    print(b[:int(a) - 1]+b[int(a):])

BJ_11721 열 개씩 끊어 출력하기 (Bronze II) 

st = input()

for i in range(len(st) // 10 + 1):

    print(st[i * 10: (i + 1) * 10])

BJ_1924 2007년 (Bronze I) 

m = [31,28,31,30,31,30,31,31,30,31,30,31]

t = ['SUN','MON','TUE','WED','THU','FRI','SAT']

a, b = map(int, input().split())

print(t[(b + sum(m[:a - 1]))%7])

KT_simonsays (1.4) 

첫줄에 N이 주어진다.

다음 N줄에 문자가 주어지는데, Simon says로 시작 할 시에, 이후에 나오는 행동을 출력하라.

N = int(input())

for _ in range(N):

    s = input()

    if s[:10] == "Simon says":

        print(s[10:])

KT_tripletexting (1.6) 

띄어쓰기 없이 같은 문자를 3번 보내는데 그중 하나는 오타이다. 원래 보내려는 문자를 출력하라.

s = input()

chunk = len(s) // 3

a = s[:chunk]

b = s[chunk:chunk * 2]

c = s[chunk * 2:]

if b == c:

    print(b)

else:

    print(a)

format | comprehension

# Number

{3.1415:.2f}                                        # 3.14 (decimal places)

print(f'{3.1415:+.2f}')                                # +3.14 (decimal places + sign)

{5:0>2d}                                        # 05 (left padding)

{5:x<4d}                                        # 5xxx        (right padding)

{5:x^4d}                                        # xx5xx (center padding)

{1000000:,}                                        # 1,000,000 (comma separator)

{1000000000:.2e}                                # 1.00e+09 (Exponent notation)

{0.35:.3%}                                        # 35.000% (Percent)

44CE_Division|Format (edit)

44CE_Division|Format

a = 5

b = 3

print(f'{10/0:.1f}')

print(f'{4/3:.1f}')

print(f'{5/3:.3f}')

print(f'{4/8:.2f}')

print(f'{-3/2:.5f}')

print(f"{a}+{b} = {a+b}")

print(f"{a}*{b} = {a*b}")

print(f"{a} is five")

print("{'version'} : {b}")

print(f"{'version'} : {b}")

BJ_10179 쿠폰 (Bronze IV) 

N = int(input())

for _ in range(N):

    price = float(input())

    print(f"${price * 0.8:.2f}")

BJ_11021 A+B - 7 (Bronze III) 

for i in range(1, int(input()) + 1):

    a, b = map(int, input().split())

    print(f"Case #{i}: {a + b}")

BJ_11022 A+B - 8 (Bronze III) 

n_test = int(input())

for i in range(1, n_test + 1):

    a, b = map(int, input().split())

    print(f"Case #{i}: {a} + {b} = {a + b}")

BJ_9295 주사위 (Bronze III)

for i in range(int(input())):

    s = list(map(int, input().split()))

    print(f'Case {i+1}: {sum(s)}')

BJ_9316 Hello Judge (Bronze III) 

n = int(input())

for i in range(1, n + 1):

    print(f"Hello World, Judge {i}!")

BJ_10178 할로윈의 사탕(Bronze III)

for _ in range(int(input())):

    a, b = map(int, input().split())

    print(f'You get {a//b} piece(s) and your dad gets {a%b} piece(s).')

BJ_5361 전투 드로이드 가격 (Bronze III)

for _ in range(int(input())):

    a, b, c, d, e = map(int, input().split())

    total = a * 350.34 + b * 230.90 + c * 190.55 + d * 125.30 + e *180.90

    print('$%.2f' %total)

BJ_2052 지수연산 (Bronze III) 

n = int(input())

print(f'{2**(-n):.{n}f}')

BJ 9610 사분면 (Bronze III) 

q1 = q2 = q3 = q4 = axis = 0

N = int(input())

for _ in range(N):

    x, y = map(int, input().split())

    if x == 0 or y == 0:

        axis += 1

    elif x > 0 and y > 0:

        q1 += 1

    elif x < 0 and y > 0:

        q2 += 1

    elif x < 0 and y < 0:

        q3 += 1

    elif x > 0 and y < 0:

        q4 += 1

print(f"Q1: {q1}")

print(f"Q2: {q2}")

print(f"Q3: {q3}")

print(f"Q4: {q4}")

print(f"AXIS: {axis}")

BJ_1075 나누기 (Bronze II) 

a, b = int(input()), int(input())

a //= 100

for n in range(b):

    if (a * 100 + n) % b == 0:

        print(f'{n:02d}')

BJ_1551 수열의 변화 (Bronze II)

n, k = map(int, input().split())

a = list(map(int, input().split(",")))

for _ in range(k):

    a = [a[i+1]-a[i] for i in range(len(a)-1)]

print(*a, sep=",")

timeloop 

첫 줄에는 N이 주어진다.

다음 N줄에

1 Abracadabra

N Abracadabra

을 출력하라

n_line = int(input())

for i in range(1, n_line + 1):

    print(f"{i} Abracadabra")

stararrangements

s = int(input())

print(f"{s}:")

for n in range(2, s // 2 + 2):

    if (s - n) % (2 * n - 1) == 0 or s % (2 * n - 1) == 0:

        print(f"{n},{n - 1}")

    if s % n == 0:

        print(f"{n},{n}")

        

li = [1, 2, 3, 4]

[n * 10 for n in li]                                # 10, 20, 30, 40

[i for i in range(30) if i % 3 == 0]                #  [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

        

lis = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]  

flattened = [el for li in lis for el in li]

print(f"{a}=5" if a == 5 else f"{a}!=5 ")

print(f"{a}=={b}" if a == b else f"{a} != {b}")

44CH_format|comprehension(edit)

44CH_format|comprehension

li = [2, 5, 3]

print([i for i in range(3)])

print([i for i in range(5) if i % 2  == 0])

print([i + j for i in range(3) for j in range(3)])

print([n for n in li])

print([n*5 for n in li])

print([n for n in li if n % 2 != 0])

print([i * n for i in li for n in li])

print([i * n for i in li for n in range(3)])

print([i * n for i in li for n in range(5) if n  % 2 != 0])

print([i // n for i in range(1,4) for n in range(1,4)])

BJE_19602 Dog Treats (Bronze IV) 

a = int(input())

b = int(input())

c = int(input())

print('sad' if a + 2 * b + 3 * c < 10 else 'happy')

BJ 15780 멀티탭 충분하니? (Bronze III)

n, k = map(int, input().split())

c = list(map(int, input().split()))

result = 0

for cc in c:

    result += (cc + 1) // 2

print('YES' if result >= n else "NO")

BJ 18247 겨울왕국 티켓 예매 (Bronze III)

T = int(input())

for _ in range(T):

    n, m = map(int, input().split())

    if m < 4 or n < 12:

    print(-1 if m < 4 or n < 12 else 11 * m + 4)

BJ_1267 핸드폰 요금(Bronze III)

input()

y = m = 0

for p in map(int,input().split()):

    y+=p//30*10+10

    m+=p//60*15+15

print('M' if y>m else 'Y' if y<m else 'Y M',min(y,m))

BJ_2547사탕 선생 고창영 (Bronze III) 

N = int(input())

for _ in range(N):

    input()

    line = int(input())

    li = [int(input()) for _ in range(line)]

    print("YES" if sum(li) % len(li) == 0 else "NO")

BJ_3058 짝수를 찾아라 (Bronze III)

N = int(input())

for _ in range(N):

    evens = [n for n in list(map(int, input().split())) if n % 2 == 0]

    print(sum(evens), min(evens))

BJ_5597 과제 안 내신 분..? (Bronze II) 

a = [int(input()) for _ in range(28)]

for i in range(1, 31):

    if i not in a:

        print(i)

BJ_2775 부녀회장이 될테야 (Bronze II) 

for _ in range(int(input())):

    k = int(input())

    n = int(input())

    people = list(range(n + 1))

    for i in range(k):

        for j in range(1, n + 1):

            people[j] = people[j] + people[j - 1]

    print(people[-1])

BJ_13458 시험 감독 (Bronze II) 

N = int(input())

A = map(int, input().split())

B, C = map(int, input().split())

print(sum(((a-B-1) // C) + 1 if a >= B else 0 for a in A) + N)

BJ_4344 평균은 넘겠지 (Bronze I) 

N = int(input())

for i in range(N):

    li = list(map(int, input().split()))

    av = sum(li[1:]) / li[0]

    print(f"{len([x for x in li[1:] if x > av]) / li[0]:.3%}")

lists | 2D

append()                # Adds an element at the end of the list

clear()                        # Removes all the elements from the list

copy()                        # Returns a copy of the list

count()                        # Returns the number of elements with the specified value

extend()                # Add the elements of a list (or any iterable), to the end of the current list

index()                        # Returns the index of the first element with the specified value

insert()                        # Adds an element at the specified position

pop()                        # Removes the element at the specified position

remove()                # Removes the first item with the specified value

reverse()                # Reverses the order of the list

sort()                        # Sorts the list

        45CE_list(edit)

        45CE_list

        a = [1, 2, 3, 4, 5]

b = [4, 5, 6, 7, 8]

a.append(99); print(a[-1])

b.remove(8); print(b[-1])

print(a.pop())

print(a[1])

b.pop(); print(len(b))

a.append('xz'); print(a[-1])

b.append(10); print(b[-1])

a[3] = 77; print(a[3])

print(a[0], b[-1])

print(b[4], a[-5])

        

        45CH_list(edit)

45CH_list

a = [1, 1, 1, 10, 20, 30]

b = ['aaa', 'w', 'x', 'xyz']

print(a.index(30))

print(b.index('aaa'))

print(sum(a))

print(b.count('x'))

print(b[1].count('a'))

print(a.count(1))

a.insert(-2, 53); print(a[4])

b.insert(4, 'th'); print(b[-1])

print(len(a + b))

print(list('abcd')[1])

BJE_11549 Identifying tea (Bronze IV) 

a = input()

print(input().split().count(a))

BJ_10797 10부제 (Bronze IV) 

a = input()

li = input().split()

print(li.count(a))

print(li)

print(a)

BJ 15784 질투진서 (Bronze III) 

N, i, j = map(int, input().split())

i, j = i - 1, j - 1

line = []

row = []

for a in range(N):

    temp = list(map(int, input().split()))

    line.append(temp[j])

    if a == i:

        row = temp

if max(line) == max(row) == row[j]:

    print('HAPPY')

else:

    print('ANGRY')

BJ_14909 양수 개수 세기 (Bronze III)

numbers = list(map(int, input().split()))

count = 0

for number in numbers:

    if number > 0:

        count += 1

print(count)

BJ_10871 X 보다 작은 수 (Bronze III) 

_, x = map(int, input().split())

for n in map(int, input().split()):

    if n < x:

        print(n, end=' ')

BJ_5217 쌍의 합 (Bronze III) 

n_test = int(input())

for _ in range(n_test):

    n = int(input())

    li = []

    for i in range(1, (n + 1) // 2):

        li.append(f"{i} {n - i}")

       

    print(f"Pairs for {n}: {', '.join(li)}")

BJ_2863 이게 분수? (Bronze III) 

a, b = map(int, input().split())

c, d = map(int, input().split())

f = [a / c + b / d, c / d + a / b, d / b + c / a, b / a + d / c]

print(f.index(max(f)))

BJ_4493 가위 바위 보?(Bronze III)

T = int(input())

for t in range(T):

    n = int(input())

    a = 0

    for i in range(n):

        b = input().rstrip()

        if b in ('P R','R S','S P'):

            a += 1

        elif b in ('R P','S R','P S'):

            a -= 1

    if a < 0 :

        print("Player 2")

    elif a > 0:

        print("Player 1")

    else:

        print("TIE")

BJ_10807 개수 세기 (Bronze II) 

input()

nums = input().split()

print(nums.count(input()))

BJ 1340 연도 진행바 (Bronze II)

month, d, y, hm = input().split()

month = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'].index(month)

d = int(d[:-1])

y = int(y)

h, m = map(int, hm.split(':'))

db = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

if y % 400 == 0 or (y % 4 == 0 and y % 100 != 0):

  db[1] = 29

total = sum(db) * 24 * 60

cur = (sum(db[:month]) + (d - 1)) * 24 * 60 + h * 60 + m

print(cur / total * 100)

BJ_10163 색종이 (Bronze I)

N = int(input())

G = [[0] * 1001 for _ in range(1001)]

for i in range(1, N + 1):

    a, b, c, d = map(int, input().split())

    for r in range(a, a + c):

        for c in range(b, b + d):

            G[r][c] = i

           

for i in range(1, N + 1):

    print(sum(li.count(i) for li in G))

BJ_11723 집합 (Silver V) 

import sys

M = int(sys.stdin.readline())

my_list = [False] * 20  # 0 ~ 19

for _ in range(M):

    c = sys.stdin.readline().split()

    if len(c) > 1:

        n = int(c[1]) - 1  # 1 ~ 20 -> 0 ~ 19

    if c[0] == 'add':

        my_list[n] = True

    elif c[0] == 'remove':

        my_list[n] = False

    elif c[0] == 'check':

        print(1 if my_list[n] else 0)

    elif c[0] == 'toggle':

        my_list[n] = not my_list[n]

    elif c[0] == 'all':

        my_list = [True] * 20

    elif c[0] == 'empty':

        my_list = [False] * 20

BJ_1292 쉽게 푸는 문제 (Silver IV) 

number_list = []

for i in range(1, 46):

    number_list += [i] * i

   

A, B = map(int, input().split())

print(sum(number_list[A-1:B]))

BJ_5397 키로거 (Silver III) 

for _ in range(int(input())):

    typing = input()

    left, right = [], []

    for ch in typing:

        if ch == '<':

            if left:

                right.append(left.pop())

        elif ch == '>':

            if right:

                left.append(right.pop())

        elif ch == '-':

            if left:

                left.pop()

        else:

            left.append(ch)

    left.extend(reversed(right))

    print(''.join(left))

45CH_lists|2D(edit)

45CH_lists|2D

print(li[-1][-1])

print(li[1][1])

print(li[1:2][0])

print(li[1:3][1])

print(li[-1][3:])

print(li[-3][-1])

print(li[2][1])

print(li[0][-3])

print(li[-4][3])

print(li[2:][2])

BJ_2566 최댓값 (Bronze III) 

G = []

for _ in range(9):

    G.append(list(map(int, input().split())))

mx, mr, mc = 0, 0, 0    

for r in range(9):    

    for c in range(9):

        if mx < G[r][c]:

            mx = G[r][c]

            mr, mc = r + 1, c + 1

print(mx)

print(mr, mc)

BJ_2675 문자열 반복 (Bronze II)

N = int(input())400 Bad Request

for _ in range(N):

    a, b = input().split()

    for ch in b:

        print(ch * int(a), end='')

    print()

BJ_10798 세로읽기 (Bronze I) 

li = [input() for _ in range(5)]

for i in range(15):

    for j in range(5):

        if i < len(li[j]):

            print(li[j][i], end='')

BJ_1652 누울 자리를 찾아라 (Bronze I) 

        a = int(input())

G = []

for i in range(a):

    G.append(input() + 'X')

G.append('X' * (a + 1))

hor, ver = 0, 0

for i in range(a):

    for j in range(a - 1):

        if G[i][j] == '.' and G[i][j + 1] == '.' and G[i][j + 2] == 'X':

            hor += 1

        if G[j][i] == '.' and G[j + 1][i] == '.' and G[j + 2][i] == 'X':

            ver += 1

print(hor, ver)

        BJ 15923 욱제는 건축왕이야!! (Bronze III) 

n=int(input())

L = []

for i in range(n):

    l = list(map(int,input().split()))

    L.append(l)

S = 0

for i in range(n):

    S += abs(L[i][0]-L[i-1][0])

    S += abs(L[i][1]-L[i-1][1])

print(S)

BJ_1100 하얀 칸 (Bronze II)

r = ''

for _ in range(8):

    r += input() + '0'

print(r[::2].count('F'))

BJ_2979 트럭 주차 (Bronze II) 

# O(1)

costs = list(map(int, input().split()))

li = []

for _ in range(3):

    e, l = map(int, input().split())

    li.extend([(e, 'e'), (l, 'l')])

   

ret, cur, last = 0, 0, 0

for time, typ in sorted(li):

    if typ == 'e':

        ret += (time - last) * costs[cur - 1] * cur

        cur += 1

    else:

        ret += (time - last) * costs[cur - 1] * cur

        cur -= 1

    last = time

       

print(ret)

BJ_11723 집합 (Silver V)

import sys

input = sys.stdin.readline

M = int(input())

my_list = [False] * 20  # 0 ~ 19

for _ in range(M):

    c = input().split()

    if len(c) > 1:

        n = int(c[1]) - 1  # 1 ~ 20 -> 0 ~ 19

    if c[0] == 'add':

        my_list[n] = True

    elif c[0] == 'remove':

        my_list[n] = False

    elif c[0] == 'check':

        print(1 if my_list[n] else 0)

    elif c[0] == 'toggle':

        my_list[n] = not my_list[n]

    elif c[0] == 'all':

        my_list = [True] * 20

    elif c[0] == 'empty':

        my_list = [False] * 20

import sys

N, M = map(int, input().split())

G = [list(sys.stdin.readline().rstrip()) for _ in range(N)]

BJ_1018 체스판 다시 칠하기 (Silver V) 

def block_cnt(r, c):

    cntWB, cntBW = 0, 0

    for i in range(r, r+8):

        for j in range(c, c+8):

            if (i - r + j - c) % 2 == 0:

                if G[i][j] == 'B':   cntWB += 1

                else:                 cntBW += 1

            else:

                if G[i][j] == 'W':  cntWB += 1

                else:                  cntBW += 1

    return min(cntWB, cntBW)

min_change = N * M

for i in range(N-7):

    for j in range(M-7):

        min_change = min(min_change, block_cnt(i, j))

       

print(min_change)

BJ_7568 덩치 (Silver V)

t=[(*map(int,input().split()),) for k in range(int(input()))]

print(*(sum(x < p and y < q for p, q in t) + 1 for x, y in t))

LC_969 pancake-sorting 

class Solution:

    def pancakeSort(self, A: List[int]) -> List[int]:

        res = []

        for x in range(len(A), 1, -1):

            i = A.index(x)

            res.extend([i + 1, x])

            A = A[:i:-1] + A[:i]

        return res

batterup 

첫번째 줄 n개의 타석이 주어지고, 다음줄에는 n개 타석에서의 각 정수가 주어진다.

N개의 정수가 주어질 때, 볼넷,스트라이크,1루타, 2루타, 3루타, 홈런은 각 -1,0,1,2,3,4 점수를나타냄

볼넷 -1의 경우 타석으로 고려하지 않음

선수의 장타율을 출력하라(장타율은 모든 타석에서의 점수를 더한 값에 n타석으로 나눈 값)

# Iterable → count

n_hit = int(input())

li = list(map(int, input().split()))

miss = li.count(-1)

print((sum(li) + miss) / (n_hit - miss))

        

missingnumbers 

첫 줄에 n이 주어진다.

다음 n줄에 숫자가 주어지는데, 이 때 띄어 넘은 수를 모든 수를 출력하라.

만약 1, 2, 3 과 같이 띄어 넘는 숫자가 없을 시는 good job을 출력하라.

n = int(input())

gap = False

prev = 0

for i in range(n):

    a = int(input())

    for j in range(prev + 1, a):

        print(j)

        gap = True

    prev = a

if not gap:

    print('good job')

shatteredcake 

첫 줄에는 원 케익의 가로 길이가 주어진다.

케익이 정확히 N등분 되어 N개의 줄에 각 조각의 가로 세로 길이가 주어지는데 이 때 원 케익의 세로 길이를 출력하라.

w = int(input())

n_split = int(input())

total = 0

for _ in range(n_split):

    a, b = map(int, input().split())

    total += a * b

print(total // w)    

Oddities 

n 이 짝수이면 n is even 홀수이면 n is odd 라고 출력하라.

n_test = int(input())

for _ in range(n_test):

    n = int(input())

    if n % 2 == 0:

        print(f"{n} is even")

    else:

        print(f"{n} is odd")

fizzbuzz

X, Y, N이 첫줄에 주어진다.

1부터 N까지의 자연수 중 X 의 배수는 Fizz, Y의 배수는 Buzz, X, Y의 동시의 배수는 FizzBuzz,

그 외에는 숫자를 출력하라.

x, y, n_line = map(int, input().split())

for i in range(1, n_line + 1):

    if i % x == 0 and i % y == 0:

        print("FizzBuzz")

    elif i % x == 0:

        print("Fizz")    

    elif i % y == 0:

        print("Buzz")    

    else:

        print(i)

basketballoneonone 

A+point 혹은 B+point와 같은 형식으로 점수를 출력 할 때 더 많은 점수를 얻는 사람을 출력하라.

s = input()

A = B = 0

for i in range(1, len(s), 2):

    if s[i - 1] == 'A':

        A += int(s[i])

    else:

        B += int(s[i])    

if A > B:

    print('A')    

else:    

    print('B')

alphabetspam 

첫줄에 문장이 주어진다.

이 때 문장에서 _의 비율, 소문자의 비율, 대문자의 비율, 나머지 부호의 비율을 각각 출력하라.

st = input()

white = 0

lower = 0

upper = 0

symbol = 0

for ch in st:

    if ch == '_':

        white += 1

    elif ch.islower():    

        lower += 1

    elif ch.isupper():

        upper += 1

    else:

        symbol += 1    

       

total = white + lower + upper + symbol

print(white / total)

print(lower / total)

print(upper / total)

print(symbol / total)

Last factorial digit 

팩토리얼을 구한 뒤 마지막 자릿 수를 구하여라.

n_test = int(input())

for _ in range(n_test):

    n = int(input())

    ret = 1

    for i in range(1, n + 1):

        ret *= i

    print(ret % 10)

hangingout 

첫줄에 테라스의 최대 인원 L과 x개의 이벤트가 주어진다.

각 x줄의 이벤트에는 ‘enter’/‘leave’ 사람수 가 주어지는데 최대 인원 이상으로는 들어올 수 없다.

이때 사람이 많아 거절 당한 이벤트의 개수를 출력하라. (거절 당할 시 enter 해도 추가가 되지 않음)

max_n, n_line = map(int, input().split())

cur, ret = 0, 0

for _ in range(n_line):

    st, n = input().split()

    n = int(n)

    if st == 'enter':

        if n + cur <= max_n:

            cur += n

        else:

            ret += 1

    else:

        cur -= n

print(ret)

cold

첫줄에는 N이, 그 다음 줄에는 N개의 숫자가 주어진다.

N개의 수 중 0보다 작은 수를 출력하라.

N = int(input())

count = 0

for n in map(int, input().split()):

    if n < 0:

        count += 1

print(count)

lostlineup 

첫 줄에 사람 수 N이 주어진다.

1은 항상 줄 앞에 선다.

둘째 줄에 2 .. N과 1과의 거리가 주어진다.

이때 원래 줄을 순서를 출력하라.

n = int(input())

ret = [1] * n

li = list(map(int, input().split()))

for i, n in enumerate(li):

    ret[n + 1] = i + 2

print(*ret)

autori 

Knuth-Morris-Pratt         → KMP

Mirko-Slavko                → MS

위와 같이 첫 글자와 - 다음에 나오는 단어를 축약시킬 수 있다. 왼쪽과 같은 인풋이 주어졌을 때 오른쪽과 같이 출력하라.

st = input()

for i, ch in enumerate(st):

    if i == 0 or st[i - 1] == '-':

        print(st[i], end='')

nastyhacks 

첫 줄에는 N이 다음 N줄에는 a, b, c가 주어진다.

a는

n_test = int(input())

for _ in range(n_test):

    a, b, c = map(int, input().split())

    if a > b - c:

        print("do not advertise")

    elif a == b - c:

        print("does not matter")

    else:

        print("advertise")

grassseed

C                1m2 에 소모되는 씨앗의 가격

L                라인 의 수

w1 l1                밭의 넓이 높이

wL lL

이 때 총 씨앗의 가격을 구하라

c = float(input())

l = int(input())

ret = 0

for _ in range(l):

    w, l = map(float, input().split())

    ret += w * l * c

print(ret)

tarifa 

첫 줄에는 데이터 한도(한 달에 사용 가능 한 데이터), 두번째 줄에는 N이 주어진다.

각 N줄에는 각 달에 사용한 데이터 량이 주어지는데, 이 때 한도보다 적게 쓸 시 다음달로 이월된다.

이때 N + 1번째 달에 사용할 수 있는 데이터 양을 출력하라.

add = int(input())

n_line = int(input())

cur = 0

for n in range(n_line):

    cur += add

    cur = max(0, cur - int(input()))

   

print(cur + add)

pot 

첫 줄에 N이 다음 N줄에는 x가 주어진다.

이 때 x의 마지막 자리는 지수이다. (Ex. 35 = 35)

x의 합을 구하라.

n_line = int(input())

ret = 0

for _ in range(n_line):

    n = int(input())

    ret += (n // 10) ** (n % 10)

print(ret)

numberfun

a, b, c가 주어 질 때, a, b와 +, -, *, / 로 c를 만들 수 있으면 Possible 불가능 하면 Impossible을 출력하라

n_test = int(input())

for _ in range(n_test):

    a, b, c = map(int, input().split())

    if a + b == c or a - b == c or b - a == c or  a * b == c or a / b == c or b / a == c:

        print("Possible")

    else:

        print("Impossible")

licensetolaunch 

N개의 숫자가 주어질 때 최소인 index를 출력하라

N = int(input())

mn, mn_idx = float('inf'), -1

for i, e in enumerate(map(int, input().split())):

    if e < mn:

        mn_idx = i

        mn = e

print(mn_idx)

avion 

5개 줄에 차량 문자가 주어진다.

이 문자에 'FBI'가 포함 되어 있는 라인 숫자를 출력하라.

하나도 없을 시 'HE GOT AWAY'를 출력하라.

seen = False

for i in range(1, 6):

    st = input()

    if 'FBI' in st:

        print(i, end=' ')

        seen = True

 

if not seen:

    print("HE GOT AWAY!")    

KT_apaxiaaans (1.5) 

문자를 받아서, 연속된 문자는 한번만 출력하라.

st = input()

for i in range(len(st)):

    if i == 0 or st[i - 1] != st[i]:

        print(st[i], end='')

KT_kemija08 (1.5) 

루카는 화학 수업 시간에 지루해서 문단에 있는 모음(a,e,i,o,u) 을 모음p모음 으로 바꾸었다.

이 바뀐 문장을 원래대로 돌려라.

st = input()

skip = 0

for ch in st:

    if skip > 0:

        skip -=1

    elif ch in 'aeiou':

        skip = 2

        print(ch, end='')    

    else:

        print(ch, end='')

KT_sumkindofproblem (1.6) 

첫 줄에 n이 주어진다.

그 다음 n 줄에 k, m이 주어지는데, 이 때 k 와 첫 m개의 자연수, 홀수, 짝수 의 합을 구하라.

n = int(input())

for i in range(n):

    k, n = map(int, input().split())

    print(k, n * (n + 1) // 2, n * (n + 1) - n, n * (n + 1))

KT_gerrymandering (1.5) 

n, m = map(int, input().split())

G = [[0, 0] for i in range(m)]

for i in range(n):

    a, b, c = map(int, input().split())

    G[a - 1][0] += b

    G[a - 1][1] += c

   

total_wa = 0

total_wb = 0

for a, b in G:

    if a < b:

        wa = a

        wb = b - (a + b) // 2 - 1

        print('B', wa, wb)

    else:    

        wa = a - (a + b) // 2 - 1

        wb = b

        print('A', wa, wb)

    total_wa += wa

    total_wb += wb

       

print(abs(total_wa - total_wb) / sum(sum(l) for l in G))

KT_encodedmessage (1.4)

n = int(input())

for _ in range(n):

    s = input()

   

    G = []

    m = int(len(s) ** 0.5)

    for i in range(m):

        G.append(s[i * m : (i + 1) * m])

       

    for j in reversed(range(m)):

        for i in range(m):

            print(G[i][j], end='')

    print()

KT_skener (1.6) 

N, M, a, b = map(int, input().split())

G = [input() for _ in range(N)]

for i in range(N):

    for _ in range(a):

        for j in range(M):

            for _ in range(b):

                print(G[i][j], end='')

        print()

KT_prva (1.7) 

n, m = map(int, input().split())

G = []

for _ in range(n):

    G.append(input() + "#")

G.append('#' * (m + 1))

words = []

for i in range(n + 1):    

    word = ""

    for j in range(m + 1):

        if G[i][j] == '#':

            if len(word) > 1:

                words.append(word)

            word = ""

        else:

            word += G[i][j]

           

for j in range(m + 1):

    word = ""

    for i in range(n + 1):

        if G[i][j] == '#':

            if len(word) > 1:

                words.append(word)

            word = ""

        else:

            word += G[i][j]

print(sorted(words)[0])

strings

KIM_17 문자열 메서드

count(‘a’)                                # count number of str

index(sub[, start[, end]])                # equivalent to find raise value error

isdigit()                                        # Checks if string only contains 0-9

isupper()                                # Return True if upper case

islower()                                # Return True if lower case

join(seq)                                      # default empty "".join([str(x) for x in l])

replace(“P”, “-”)                        # replace P to -

find(sub[, start[, end]])                        # lowest index in the string where substring sub is found | -1 if not

rfind(str, beg=0 end=len(string))        # highest index in the string where substring sub is found | -1 if not

rjust(width[, fillchar])                        # right justified in a string of specified length

rstrip([chs])                                # default whitespaces | e.x. 'mississippi'.rstrip('ipz') → 'mississ'

split(sep=None, maxsplit=-1)                # using sep as the delimiter string

startswith(str, beg=0,end=len(self))        # check if starts with str

strip()                                        # removes chars from side (default whitespace)

swapcase()                                # all the upper case letters are lower case and vice versa

title()                                        # Upper only first char

43CE_strings(edit) 

43CE_strings

a = "abcdefaa"

b = "bcd"

print(a.count(a))

print(a.count('a'))

print(a.count('abc'))

print(a.count(b))

print(b.count(a))

print(b.replace('b', 'llll'))

print((a + b).replace('b', 'llll'))

print(b.replace(a, b))

print(a.replace(b, a))

print(a.replace(b, b + b))

43CH_strings(edit) 

43CH_strings

a = "abcdefaa"

b = "bcd"

print(a.find(a))

print(a.find('a'))

print(a.find('aa'))

print(a.find(b))

print(b.find(a))

print(b in a)

print(b in b)

print(b + b in a)

print((b in b) == (a in a))

print((a in a) == (b in b))

BJ_2875 FBI (Bronze III) 

count = 0

for i in range(1, 6):

    if input().find('FBI') != -1:

        print(i, end=' ')

        count +=1

if count == 0:

    print("HE GOT AWAY!")

BJ_4458 첫 글자를 대문자로 (Bronze II) 

for i in range(int(input())):

  j = input()

  print(j[0].upper() + j[1:])

BJ_2577 숫자의 개수 (Bronze II) 

a = int(input())

b = int(input())

c = int(input())

        

s = str(a * b * c)

for i in range(10):

    print(s.count(str(i)))

BJ_10987 모음의 개수 (Bronze II) 

a = input()

print(a.count('a') + a.count('e') + a.count('i') + a.count('o') + a.count('u'))

BJ_2864 5와 6의 차이 (Bronze II) 

a, b = input().split()

mx = int(a.replace('5', '6')) + int(b.replace('5', '6'))

mn = int(a.replace('6', '5')) + int(b.replace('6', '5'))

print(mn, mx)

BJ_10809 알파벳 찾기 (Bronze II)

s = input()

for i in range(ord('a'), ord('z') + 1):

    print(s.find(chr(i)), end=' ')

BJ_2744 대소문자 바꾸기 (Bronze II) 

st = input()

for ch in st:

    if ch.islower():

        print(ch.upper(), end='')

    else:    

        print(ch.lower(), end='')

BJ_2902 KMP는 왜 KMP일까 (Bronze II) 

for i in input():

    if i.isupper():

        print(i, end='')

BJ_2810 컵홀더 (Bronze II) 

input()

s = input()

if 'L' not in s:

    print(len(s))

else:

    print(len(s.replace("LL", "S")) + 1)

BJ_1343 폴리오미노 (Silver IV) 

a=input().replace('XXXX','AAAA').replace('XX','BB')

print(-1 if 'X' in a else a)

s = input()

k = input()

print(int(k in s))

KT_quickestimate (1.4) 

첫번째 줄에는 N이 그 다음 N 줄에는 x가 주어진다. 이때 각 줄마다 x의 자리수를 출력하라.

n_line = int(input())

for _ in range(n_line):

    x = input()

    print(len(x))

KT_deathknight (1.9) 

첫줄에 N이 주어진다.

다음 각각 N줄에 문자가 주어지는데, 이 때 CD를 포함하지 않는 줄의 수를 구하여라.

n = int(input())

ret = 0

for _ in range(n):

    if input().find('CD') == -1:

        ret += 1

print(ret)

KT_Hissing_microphone (1.4) 

input에 ss, 즉 연속된 s가 있을 시 'hiss' 그렇지 않으면 'no hiss'를 출력한다.

        # Using for

s = input()

for i in range(1, len(s)):

    if s[i] == s[i - 1] == 's':

        print("hiss")

        break

else:

    print("no hiss")

# Using find

s = input()

if s.find('ss') == -1:

    print('no hiss')

else:

    print('hiss')

KT_fiftyshades (1.4) 

첫줄엔 N 이 그 다음 N 줄엔 문자가 주어진다.

이 때 rose나 pink를 포함한 문자의 수를 구하라. (단 대문자 / 소문자는 무시한다.)

N = int(input())

count = 0

for _ in range(N):

    st = input().lower()

    if st.find('pink') != -1 or st.find('rose') != -1:

        count += 1

       

print(count if count != 0 else "I must watch Star Wars with my daughter")

KT_dicegame (1.5) 

두줄에 거쳐 총 8개의 수가 주어진다.

이 때 위 줄의 합이 크면 Emma 아랫줄의 합이 크면 Gunnar, 같을 시에는 Tie를 출력하라.

a = sum(map(int, input().split()))

b = sum(map(int, input().split()))

if a < b:

    print('Emma')

elif b < a:

    print('Gunnar')    

else:

    print('Tie')    

KT_runlengthencodingrun (1.7) 

예제 참조

t, s = input().split()

if t == 'E':

    row = 1

    for i, ch in enumerate(s):

        if i == len(s) - 1 or s[i + 1] != s[i]:

            print(ch + str(row), end='')

            row = 1

        else:    

            row+=1

else:

    for i in range(1, len(s), 2):

        print(s[i - 1] * int(s[i]), end='')

KT_apaxianparent (1.5) 

문자 Y, P가 주어진다.

1. Y가 ex로 끝날 시 Y + P

2. Y가 e로 끝날 시 Y + 'e' + P

3. Y가 aiou 로 끝날 시 그 모음을 제거하고 Y + 'ex' + P

4. 위에 어느 것도 아닐 시 Y + 'ex' + P

를 출력한다

a, b = input().split()

if a[-1] == 'e':

    print(a, 'x', b, sep='')

elif a[-2:] == 'ex':

    print(a, b, sep='')

elif a[-1] in 'aiou':

    print(a[:-1], 'ex', b, sep='')

else:

    print(a, 'ex', b, sep='')

KT_ostgotska (1.7) 

문장에 ae가 포함 된 단어가 40% 이상이면 스웨덴 어이다.

첫 줄에 문장이 주어질 때 스웨덴 어이면 dae ae ju traeligt va 아니면 haer talar vi rikssvenska 을 출력하라.

li = input().split()

n = len(li) * 0.4

count = 0

for st in li:

    if "ae" in st:

        count += 1

if n <= count:        

    print("dae ae ju traeligt va")

else:

    print("haer talar vi rikssvenska")

while, break | continue

        

        48CH_while(edit)

48CH_while

i = 1

n = 10

while i < 5:    print(i, end = ' '); i += 1

while i < 5:    print(i * 5, end = ' '); i += 1

while i <  5:    print(i, end = ' '); i *= 2

while n > 0:    print(n, end = ' '); n//=2

while n != 0:    print(n, end = ' '); n-= 2

while n % 2 == 0 and n > 0:    print(n, end = ' '); n -= 1

while n > 0 and i < 10:    print(i*n, end = ' '); i += 2; n -= 2

while n > i:    print(n, end = ' '); n -= 1; i += 1

while i != n:    print(i);     i -= 1

while n > i:    print(n, end = ' ');    n -= i

BJ_10474 분수좋아해? (Bronze III)

while True:

    a, b = map(int, input().split())

    if a == 0 and b == 0:

        break

    print(a//b, a % b, '/', b)

BJ_10409 서버 (Bronze III) 

n, T = map(int, input().split())

times = list(map(int, input().split()))

count = 0

for time in times:

    T -= time

    if T < 0:

        break

    count += 1

print(count)

        

BJ_4880 다음수 (Bronze III) 

while True:

    a, b, c = map(int, input().split())

    if a == b == c == 0:

        break

    if c - b == b - a:

        print(f"AP {c + (b - a)}")

    else:

        print(f"GP {c * (b // a)}")

BJ_5073 삼각형과 세 변 (Bronze III) 

while True:

    A, B, C = map(int, input().split())

    if A == B == C == 0:

        break

    if max(A, B, C) >= A + B + C - max(A, B, C):

        print("Invalid")

    elif A == B == C:

        print("Equilateral")

    elif A == B or B == C or A == C:

        print("Isosceles")

    else:

        print("Scalene")

BJ_5086 배수와 약수 (Bronze III)

while True:

    a, b = map(int, input().split())

    if a == 0 and b == 0:

        break

    if b % a == 0:

        print('factor')

    elif a % b == 0:

        print('multiple')

    else:

        print('neither')

BJ_4766 일반 화학 실험 (Bronze III)

last = float(input())

while True:

    n = float(input())

    if n == 999:

        break

    print(f"{n - last:.2f}")

    last = n

BJ_5717 상근이의 친구들 (Bronze III) 

BJ_10952 A + B - 5 (Bronze III) 

while True:

    a, b = map(int, input().split())

    if a == b == 0:

        break

    else:

        print(a + b)

BJ_4101 크냐? (Bronze III) 

while True:

    a, b = map(int, input().split())

    if a == b == 0:

        break

    if a > b:

        print("Yes")

    else:

        print("No")

        BJ_4153 직각삼각형 (Bronze III) 

while True:

    a, b, c = sorted(map(int, input().split()))

    if a == 0:

        break

    if c ** 2 == a ** 2 + b ** 2:

        print("right")

    else:

        print('wrong')

BJ_1837 암호제작 (Bronze III) 

a, b = map(int, input().split())

for n in range(2, b):

    if a % n == 0:

        print("BAD", n)

        break

else:        

    print("GOOD")

BJ_4504 배수 찾기 (Bronze III) 

a = int(input())

while True:

    b = int(input())

    if b == 0:

        break

    if b % a == 0:    

        print(b, f"is a multiple of {a}.")

    else:    

        print(b, f"is NOT a multiple of {a}.")

BJ_14920 3n+1 수열 (Bronze III)

cn = int(input())

count = 1

while cn != 1:

    count += 1

    if cn % 2 == 0:

        cn = cn // 2

    else:

        cn = 3 *cn + 1

print(count)

BJ_5612 터널의 입구와 출구 (Bronze III)

n = int(input())

m = res = int(input())

for _ in range(n):

    a,b = map(int, input().split())

    m += a - b

    res = max(m,res)

    if m < 0:

        print(0)

        break

else:

    print(res)

BJ_2231 분해합 (Bronze II) 

N = int(input())

print_num = 0

for i in range(N+1):

    sum_num = i + sum(map(int, str(i)))

    if(sum_num == N):

        print(i)

        break

else:

    print(0)

BJ_1110 더하기 사이클 (Bronze I) 

n = int(input())

m = n

i = 0

while True:

    m = m % 10 * 10 + (m % 10 + m // 10) % 10

    i += 1

    if m == n:

        print(i)

        Break

BJ_2292 벌집 (Bronze II) 

def solution(a):

    ret, cur = 1, 1

    while cur < a:

        cur += 6 * ret

        ret += 1

    return ret

print(solution(int(input())))

BJ_5585 거스름돈 (Bronze II) 

ret = 0

for coin in [500, 100, 50, 10, 5, 1]:

    while (coin <= n):

        n -= coin

        ret+=1

       

print(ret)

BJ_1193 분수찾기 (Bronze II) 

n=int(input())

A=0

B=1

while n>A:

    A+=B

    B+=1

if B%2==0:

    print(f'{1+A-n}/{B-(1+A-n)})

else:

    print(f'B-(1+A-n)/1+A-n')

BJ_3943 헤일스톤 수열 (Bronze I) 

n_test = int(input())

for _ in range(n_test):

    n = int(input())

   

    mx = 1

    while n != 1:

        mx = max(mx, n)

        if n % 2 == 0:

            n //= 2

        else:    

            n = n * 3 + 1

    print(mx)

BJ_1259 팰린드롬 수 (Bronze I) 

def is_palin(st):

    for i in range(len(st)):

        if st[i] != st[len(st) - i - 1]:

            return False

    return True

while True:

    n = input()

    if n == '0':

        break

    if is_palin(n):

        print("yes")

    else:

        print("no")

n = 1000- int(input())

BJ_4673 셀프 넘버 (Bronze I) 

li = [True] * 10090

def d(n):

    ret = n

    while n:

        ret += n % 10

        n //= 10

    return ret

for n in range(10000):

    li[d(n)] = False

   

for i in range(10001):

    if li[i]:

        print(i)

n = int(input())

BJ_1158 요세푸스 문제 (Silver V) 

n,k=map(int,input().split(' '))

index=k-1

a=list(range(1,n+1))

r=[]

while a:

    index%=len(a)

    r.append(str(a.pop(index)))

    index+=k-1

print("<"+", ".join(r)+">")

BJ_1436 영화감독 숌 (Silver V) 

name = 666

cnt=0

while(True):

    if "666" in str(name):

        cnt+=1

        if cnt == n :

            print(name)

            break

    name+=1

BJ_1543 문서 검색 (Silver IV) 

doc = input()

word = input()

count = 0

i = 0

while i <= len(doc) - len(word):

    if doc[i:i + len(word)] == word:

        count += 1

        i += len(word)

    else:

        i += 1

print(count)

KT_zamka (1.4)

mn = int(input())

mx = int(input())

sm = int(input())

def match(n, sm):

    while n != 0:

        sm -= n % 10

        n //= 10

    return sm == 0    

for i in range(mn, mx + 1):    

    if match(i, sm):

        print(i)

        break

for i in range(mx, mn - 1, -1):

    if match(i, sm):

        print(i)

        break

KT_reverserot (1.7) 

숫자 a, 문자 b가 매 줄마다 주어진다.

이 때 문자를 뒤집어서 a만큼 회전한 문자를 출력한다. (단 Z → _ → . → A 으로 순환된다)

마지막 줄에는 0만 나온다.

alp = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_.'

while True:

    raw = input()

    if raw == '0':

        break

    shift, st = raw.split()

    shift = int(shift)

    for ch in reversed(st):

        print(alp[(alp.find(ch) + shift) % len(alp)], end='')

    print()

KT_bookingaroom (1.6) 

첫 줄에 a, b가 주어진다. 이 때 a는 총 방의 개수이다. (1...n)

다음 b 줄에 예약된 방 번호가 주어진다.

이때 아무 빈 방을 출력하라.

빈 방이 없을 시 too late을 출력하라.

a, b = map(int, input().split())

se = set()

for _ in range(b):

    se.add(int(input()))

for i in range(1, a + 1):

    if i not in se:

        print(i)

        break

else:

    print("too late")

KT_mixedfractions (1.5) 

각 줄에 a, b 가 주어진다.

이 때 a / b 인 분수를 대분수로 형식으로 출력하라.

        a, b가 둘다 0 일 경우 종료한다.

while True:

    dem, num = map(int, input().split())

    if dem == num == 0:

        break

    print(dem // num, dem % num, '/', num)

KT_sodaslurper (1.6) 

첫 줄에 e, f, c 가 주어진다.

e와 f 를 합치면 가지고 있는 총 빈 병의 개수가 나오고,

병을 c개 가지고 오면 꽉 찬 음료수를 받을 수 있다.

이 때 총 마실 수 있는 음료수의 수를 출력하라.

e, f, c = map(int, input().split())

e += f

ret = 0

while e >= c:

    ret += e // c

    e = e % c + e // c

   

print(ret)

KT_differentdistances (1.7) 

x1, x2, y1, y2이 주어진다.

이때 를 출력하라.

마지막 줄에 0이 나온다.

while True:

    raw = input()

    if raw == '0':

        break

    a, b, c, d, e = map(float, raw.split())

    print((abs(a - c) ** e + abs(b - d) ** e) ** (1/e))

KT_harshadnumbers (1.4) 

harshad 수는 각 자리 수를 다 더한 수로 나누어 떨어지는 수이다.

n이 주어질 때 n보다 크거나 같은 가장 작은 harshad 수를 출력하라.

def is_harshad(num):

    digit_sum = 0

    cur = num

    while cur != 0:

        digit_sum += cur % 10

        cur //= 10

    return num % digit_sum == 0

n = int(input())

while True:

    if is_harshad(n):

        print(n)

        break

    n = n + 1

KT_sumsquareddigits (1.5) 

N-test개의 줄에  k(data set 수),b,n 정수가 주어진다

k개의 줄에 각 test 번호 k와 SSB(b,n)을 출력하라

n_test = int(input())

def SSD(b, n):

    ret = 0

    while n != 0:

        ret += (n % b) ** 2

        n //= b

    return ret    

for _ in range(1, n_test + 1):

    K, b, n = map(int, input().split())

    print(f'{K} {SSD(b, n)}')

KT_easiest (1.7)

def SOD(st):

    return sum(map(int, st))

while True:

    n = input()

    if n == '0':

        break

    for i in range(11, 100000):

        if SOD(n) == SOD(str(int(n) * i)):

            print(i)

            break

KT_symmetricorder (1.6)

si = 0

while True:

    si += 1

    n = int(input())

   

    if n == 0:

        break

   

    print(f"SET {si}")

    li = [input() for _ in range(n)]

    for i in range(0, n, 2):

        print(li[i])

    for i in range(1, n, 2):

        print(li[i])

KT_cudoviste (1.4)

N, M이 주어지고 N개의 라인의 주차장이 주어진다.

이 때 . 은 빈칸, '#' 은 건물, 'X' 는 다른 차량이다.

        2x2의 차를 주차 할 때 0, 1, 2, 3, 4개의 차량을 치우고 댈 수 있는 가지 수를 각 라인에 출력하라.

N, M = map(int, input().split())

G = []

for _ in range(N):

    G.append(input())

rets = [0, 0, 0, 0, 0]    

for i in range(1, N):

    for j in range(1, M):

        spaces = [G[i - 1][j - 1], G[i - 1][j], G[i][j - 1], G[i][j]]

        if '#' in spaces:

            continue

        rets[spaces.count('X')] += 1

for ret in rets:

    print(ret)

[5] Hashing

set

51CE_set(edit)

51CE_set

a = set(['a', 'b', 'b'])

b = set(['b', 'c', 'd'])

print('d' in a)

print('d' in a | b)

print(" ".join(sorted(a)))

print(" ".join(sorted(a & b)))

a.remove('a'); print(" ".join(a))

print(" ".join(sorted(a | b)))

print(" ".join(sorted(a | {'z'})))

a.add('f'); print(" ".join(a))

print(" ".join(sorted(a - b)))

print(" ".join({'1', '1'}))

BJ_15829 Hashing (Bronze II) 

n = int(input())

st = (input())

has = 0

for i, ch in enumerate(st):

    has = (has + 31 ** i * (ord(ch) - ord('a') + 1)) % 1234567891    

print(has)

BJ_3052 나머지 (Bronze II) 

st = set()

for i in range(10):

    st.add(int(input()) % 42)

print(len(st))

BJ_1453 피시방 알바 (Bronze I) 

input()

li = list(map(int, input().split()))

print(len(li) - len(set(li)))

BJ_7785 회사에 있는 사람 (Silver V)   

import sys

input = sys.stdin.readline

n, m = map(int, input().split())

names = []

name2i = {}

for i in range(n):

    name = input().strip()

    names.append(name)

    name2i[name] = i

   

for _ in range(m):

    i = input().strip()

    if i.isdigit():

        print(names[int(i) - 1])

    else:

        print(name2i[i] + 1)

BJ_1822 차집합 (silver IV)

N, M = map(int, input().split())

A = set(map(int, input().split()))

B = set(map(int, input().split()))

li = list(sorted(A - B))

print(len(li))

print(*li)

BJ_10815 숫자 카드 (Silver IV) 

input()

se = set(map(int, input().split()))

input()

for n in map(int, input().split()):

    print(1 if n in se else 0)

BJ_1764 듣보잡 (Silver IV) 

n, m = map(int, input().split())

hear = set(input() for _ in range(n))

watch = set(input() for _ in range(m))

print(len(hear & watch))

print("\n".join(sorted(hear & watch)))

KT_icpcawards (1.4)

첫 줄에는 N, 다음 N 줄엔 대학이름 팀이름이 순위대로 주어진다.

상을 받는 상위 12팀 이름을 출력하라, 단 한 대학에서는 한 팀만 상을 받을 수 있다.

N = int(input())

seen = set()

for _ in range(N):

    uni, team = input().split()

    if uni not in seen and len(seen) < 12:

        print(uni, team)

    seen.add(uni)

KT_everywhere (1.3) 

첫 줄에 테스트 케이스 수.

각 테스트 케이스는 N 과 N개의 줄에 도시이름이 주어진다.

이 때 다른 도시 개수를 출력하라.

n_test = int(input())

for _ in range(n_test):

    N = int(input())

    se = set()

    for _ in range(N):

        se.add(input())

    print(len(se))

KT_modulo (1.4)

10개의 수가 주어지는데 이 때 42의 나머지의 가짓수를 구하라.

st = set()

for i in range(10):

    st.add(int(input()) % 42)

print(len(st))

KT_securedoors (1.9) 

첫줄에 N이 주어지고 그 다음 N줄에 방명록이 주어진다.

방명록은 입장 이름 / 퇴장 이름과 같은 형식으로 주어지는데,

이 때 퇴장 전 입장을 여러번 했거나 입장 하지 않았는데 퇴장 한 경우는 (ANOMALY)를 출력한다.

N = int(input())

se = set()

for _ in range(N):

    typ, name = input().split()

    if typ == 'entry':

        if name in se:

            print(name, 'entered', '(ANOMALY)')

        else:    

            print(name, 'entered')

            se.add(name)

    else:

        if name in se:

            print(name, 'exited')

            se.remove(name)

        else:

            print(name, 'exited', ('(ANOMALY)' if name not in se else ''))

dictionary | Counter

52CE_dictionary|counter(edit)

52CE_dictionary|counter

print(d1['a'])

print(d2['c'])

print(d1['a'] + d2['c'])

print(d1['c'] + d2['a'])

print('a' in d1)

print('d' in d2)

print(d2['b']*d1['b'])

print(d1 + d2)

print(d2['d'])

print(list(d2.values()))

52CH_dictionary|Counter(edit)

52CH_dictionary|Counter

from collections import Counter

a = Counter([1, 2, 3, 4, 5, 5])

b = Counter([-1, 2, 3, 4, 4, 5])

print(a[3])

print(b[4])

print(a[-2])

print(b[-1])

print((a + b)[4])

print((a + b)[-1])

print((a-b)[5])

print((b-a)[5])

print((a+a)[4])

print((b+b)[4])

BJ_2754 학점계산 (Bronze III) 

GPA = {'A+': 4.3, 'A0': 4.0, 'A-': 3.7, 'B+': 3.3, 'B0': 3.0, 'B-': 2.7, 'C+': 2.3, 'C0': 2.0, 'C-': 1.7,

       'D+': 1.3, 'D0': 1.0, 'D-': 0.7, 'F': 0.0}

print(GPA[str(input())])

BJ_17219 비밀번호 찾기 (Silver IV) 

N, Q = map(int, input().split())

site2pw = {}

for _ in range(N):

    site, pw = input().split()

    site2pw[site] = pw

for _ in range(Q):

    print(site2pw[input()])

KT_synchronizinglists (1.5) 

while True:

    n = int(input())

   

    if n == 0:

        break

       

    l1 = [int(input()) for _ in range(n)]

    l2 = list(sorted([int(input()) for _ in range(n)]))

    rank = {}

    for i, e in enumerate(sorted(l1)):

        rank[e] = i

    for e in l1:

        print(l2[rank[e]])

    print()

        BJ_10102 개표 (Bronze II)

import collections

input()

co = collections.Counter(input())

if co['A'] < co['B']:

    print('B')

elif co['B'] < co['A']:

    print('A')

else:

    print("Tie")

 

BJ_2358 평행선 (Bronze II) 

from collections import Counter

N = int(input())

x_cnt = Counter()

y_cnt = Counter()

for _ in range(N):

    x, y = map(int, input().split())

    x_cnt[x] += 1

    y_cnt[y] += 1

   

ret = 0

for x in x_cnt:

    if x_cnt[x] > 1:

        ret += 1

for y in y_cnt:

    if y_cnt[y] > 1:

        ret += 1

print(ret)

BJ_1919 애너그램 만들기 (Bronze II) 

import string

from collections import Counter

cnt1 = Counter(input())

cnt2 = Counter(input())

ret = 0

for ch in string.ascii_lowercase:

    ret += abs(cnt1[ch] - cnt2[ch])

print(ret)

BJ_1371 가장 많은 글자 (Bronze II) 

from collections import Counter

import sys

input = sys.stdin.read

co = Counter(input().replace(' ', '').replace('\n', ''))

for k in sorted(co.keys()):

    if co[k] == max(co.values()):

        print(k, end='')

BJ_5533 유니크 (Bronze I)

from collections import Counter

N = int(input())

G = []

c1 = Counter()

c2 = Counter()

c3 = Counter()

for _ in range(N):

    a, b, c = map(int, input().split())

    c1[a] += 1

    c2[b] += 1

    c3[c] += 1

    G.append([a, b, c])

for a, b, c in G:

    print((a if c1[a] == 1 else 0) + (b if c2[b] == 1 else 0) + (c if c3[c] == 1 else 0))

BJ_1157 단어 공부 (Bronze I) 

import collections

st = input()

cnter = collections.Counter(st.lower())

mc = cnter.most_common(2)

if len(mc) == 2 and mc[0][1] == mc[1][1]:

    print('?')

else:

    print(mc[0][0].upper())

BJ_1316 그룹 단어 체커 (Silver V) 

def is_group(st):

    dic = {}

    for i, ch in enumerate(st):

        if ch in dic and dic[ch] != i - 1:

            return False

        dic[ch] = i

    return True

   

n_test = int(input())

ret = 0

for _ in range(n_test):

    if is_group(input()):

        ret += 1

print(ret

BJ_1620 나는야 포켓몬 마스터 (Silver IV) 

import sys

input = sys.stdin.readline

n, m = map(int, input().split())

names = []

name2i = {}

for i in range(n):

    name = input().strip()

    names.append(name)

    name2i[name] = i

   

for _ in range(m):

    i = input().strip()

    if i.isdigit():

        print(names[int(i) - 1])

    else:

        print(name2i[i] + 1)

        

BJ_11652 카드 (Silver IV) 

import sys

from collections import Counter

n_test = int(input())

dic = Counter()

top, ret = 0, 0

for _ in range(n_test):

    n = int(sys.stdin.readline())

    dic[n]+=1

    if dic[n] > top or dic[n] == top and n < ret:

        top, ret = dic[n], n

print(ret)

BJ_10816 숫자 카드2 (Silver IV) 

import collections

input()

cnt = collections.Counter(map(int, input().split()))

input()

for n in map(int, input().split()):

    print(cnt[n])

BJ_2607 비슷한 단어 (Silver IV)

from collections import Counter

def is_sim(a, b):

    c1 = Counter(a)

    c2 = Counter(b)

    return max(sum((c1 - c2).values()), sum((c2 - c1).values())) <= 1

   

n = int(input())

li = [input() for _ in range(n)]

ret = 0

for i in range(1, n):

    if is_sim(li[0], li[i]):

        ret += 1

print(ret)

KT_yinyangstones (1.7) 

W와 B의 개수가 같으면 1 아니면 0을 출력하라.

from collections import Counter

cnt = Counter(input())

print(1 if cnt['W'] == cnt['B'] else 0)

KT_bela (1.3) 

첫 줄의 N과 B이 주어진다.

그 다음 N줄에 Value, Suit 이 주어지는데,

Suit 이 B와 같을 시 Dominant, 다를 시 Not dominant 점수를 얻는다. 총 합을 출력하라.

n_line, suit = input().split()

n_line = int(n_line)

dic = {'A': (11, 11), 'K': (4, 4), 'Q': (3, 3), 'J':(20, 2), 'T': (10, 10), '9': (14, 0), '8' : (0, 0), '7': (0, 0)}

ret = 0

for _ in range(n_line * 4):

    card = input()

    if card[1] == suit:

        ret += dic[card[0]][0]

    else:

        ret += dic[card[0]][1]

print(ret)

KT_pokerhand (1.4) 

5개의 포커카드가 주어진다.

첫번째 문자가 카드의 랭크인데 이때 가장 많이 등장하는 랭크의 개수를 출력하라

from collections import Counter

cnter = Counter()

for card in input().split():

    cnter[card[0]]+=1

print(cnter.most_common(1)[0][1])

KT_pet (1.4) 

5명의 사람이 요리 대결을 한다.

최고점을 받은 사람의 줄 수와 총점을 출력하라

from collections import Counter

cnter = Counter()

for i in range(5):

    cnter[i + 1] = sum(map(int, input().split()))

print(*cnter.most_common(1)[0])

KT_sevenwonders (1.5)

문자열이 주어진다.

이 때 T, C, G 중 가장 적게 나온 개수 * 7 + T 개수^2 + C 개수^2 + G 개수^2 의 합을 구하라

from collections import Counter

st = input()

co = Counter(st)

ret = min(co['T'], co['C'], co['G']) * 7

ret += co['T'] ** 2

ret += co['C'] ** 2

ret += co['G'] ** 2

       

print(ret)

KT_peragrams (1.7) 

Peragrams은 문자를 뒤섞었을 때 Palindrome이 되는 문자다.

첫 줄에 문자열이 주어 졌을 때 최소 문자 몇개를 제거해야 Peragrams이 되는지 출력하라.

from collections import Counter

cnt = Counter()

for ch in input():

    cnt[ch] += 1

ret = 0

for count in cnt:

    if cnt[count] % 2 == 1:

        ret += 1

print(max(0, ret - 1))

KT_whatdoesthefoxsay (2.1)

한 테스트 마다

첫 줄에 띄어쓰기로 나누어진 울음 소리

두번째 줄부터는 animal says ~

마지막 줄에는 what does the fox say?  가 나온다.

이때 다른 동물이 내지 않은 울음소리를 모두 출력하라.

n_test = int(input())

for _ in range(n_test):

    li = input().split()

    s = input()

    ignore = set()

    while s != 'what does the fox say?':

        ignore.add(s.split()[-1])

        s = input()

    for e in li:

        if e not in ignore:

            print(e, end=' ')

KT_acm (1.5) 

문제를 풀 때 정답이면 정답인 시간을 더하고,

오답이면 그 문제에 대한 penalty가 20분 씩 쌓여 그 문제를 맞았을 때 기존에 쌓인 페널티를 합쳐서 시간을 계산한다.

시간, 문제, 결과가 입력 될 때 총 시간을 구하라

-1 이 입력될 까지 계속 된다.

from collections import Counter

total_score = total_time = 0

penalty = Counter()

while True:

    st = input()

    if st == '-1':

        break

    t, prob, result = st.split()    

    t = int(t)

   

    if result == 'wrong':

        penalty[prob] += 20

    elif result == 'right':

        total_time += t + penalty[prob]

        total_score += 1

       

print(total_score, total_time)

KT_patuljci (1.7) 

        9개의 숫자가 주어진다. 그 중 7개의 숫자의 합은 100이다. 그 7개의 숫자를 출력하라.

from itertools import combinations

li = []

for _ in range(9):

    li.append(int(input()))

for p in combinations(li, 7):

    if sum(p) == 100:

        print(*p, sep='\n')

        break        

KT_parking (1.4)

직선으로 되어있는 시장에서 모든 n개의 가게에서 장을 본다.

이때 총 이동거리를 최소화 시키는 시작점에서 모든 장을 보고 돌아오는 데까지 걸리는 거리를 출력하라.

n_test = int(input())

for i in range(n_test):

    N = int(input())

    li = list(map(int, input().split()))

    print((max(li) - min(li)) * 2)

KT_qaly (1.3) 

첫 줄에는 n이, 그 다음 n 번째 줄에는 a, b가 주어진다.

n개의 a * b 의 합을 구하라.

n_line = int(input())

ret = 0

for _ in range(n_line):

    a, b = map(float, input().split())

    ret += a * b

print(ret)

KT_helpaphd (1.5) 

n개 줄의 a + b가 주어진다. 이 때 결과 값을 출력하라. 단 P=NP 가 주어질 때는 skipped를 출력하라.

n_test = int(input())

for _ in range(n_test):

    line = input()

    if line == 'P=NP':

        print('skipped')

    else:

        print(eval(line))

KT_tri (1.6) 

a, b, c 가 주어질 때

사칙연산으로 a ? b = c가 되거나 a = b ? c가 되는 경우중 한가지를 출력하라

a, b, c = input().split()

for op in ['+', '-', '*', '/']:

    if eval(a + op + b) == int(c):

        print(a + op + b + '=' + c)

        break

    if int(a) == eval(b + op + c):

        print(a + '=' + b + op + c)

        break

KT_quickbrownfox (1.5) 

N개의 문장에 영어 알파벳 a-z까지 없는 알파벳을 출력하라. 모두 있을 시 pangram을 출력하라. 

N = int(input())

for _ in range(N):

    sentence = input().lower()

    missings = []

    for ch in 'abcdefghijklmnopqrstuvwxyz':

        if ch not in sentence:

            missings.append(ch)

    if len(missings) == 0:

        print("pangram")        

    else:

        print("missing " + "".join(missings))

KT_irepeatmyself (2.5) 

def shortest_pattern(sentence):

    n = len(sentence)

    for i in range(1, n + 1):

        if (sentence[:i] * (n // i + 1))[:n] == sentence:

            return i

    return n

   

N = int(input())

for i in range(N):

    sent = input()

    print(shortest_pattern(sent))

LC_347 top-k-frequent-elements 

def topKFrequent(self, nums: List[int], k: int) -> List[int]:

    co = collections.Counter(nums)

    return [a for a, b in co.most_common(k)]

[6] Sort

Join | Reversed

61CE_Join | Reversed(edit)

61CE_Join | Reversed

print(' '.join(['1', '2', '3']))

print(' '.join(['1']))

print('+'.join(['1', '2', '3']))

print('+'.join(['1']))

print('+'.join("ABC"))

print('-'.join(reversed(['a', '', 'a'])))

print('-'.join(reversed(['', '', 'a'])))

print('-'.join(reversed([1, 2, 3])))

print('-'.join(reversed('abcd')))

print('-'.join(reversed(['1', '2', '3'])))

BJ_1357 뒤집힌 덧셈 (Bronze I) 

a, b = map(int, input().split())

def rev(a):

    return int("".join(reversed(str(a))))

print(rev(rev(a) + rev(b)))

BJ_17608 막대기 (Bronze II)

# submit in pypy  KOI 2019 1차대회

a = int(input())

li = []

for _ in range(a):

    li.append(int(input()))

   

mx, ret = 0, 0    

for n in reversed(li):

    if mx < n:

        mx = n

        ret += 1

       

print(ret)

BJ_11945 뜨거운 붕어빵 (Bronze II)

n, m = map(int, input().split())

for i in range(n):

    print("".join(reversed(input())))

BJ_11365 !밑비 급일 (Bronze II)

while True:

    a = input()

    if a == "END":

        break

    print("".join(reversed(a)))

BJ_1668 트로피 진열 (Bronze II)

def count_visible(li):

    count, cur_mx = 0, 0

    for e in li:

        if e > cur_mx:

            count += 1

            cur_mx = e

    return count

li=[int(input()) for _ in range(int(input()))]

print(count_visible(li))

print(count_visible(reversed(li)))

KT_mirror (1.7) 

예제 참조

n_test = int(input())

for test in range(1, n_test + 1):

    R, C = map(int, input().split())

    G = [input() for _ in range(R)]

    print(f"Test {test}")

    for st in reversed(G):

        print("".join(reversed(st)))

sorted, sort

KIM_23 리스트 메서드

BJ_13866 팀 나누기 (Bronze IV) 

a, b, c, d = sorted(map(int, input().split()))

print(abs(d + a - (b + c)))

        

        BJ_2752 세 수 정렬 (Bronze IV) 

li = list(map(int, input().split()))

print(*sorted(li))

BJ_16199 나이 계산하기 (Bronze IV) 

y1, m1, d1 = map(int, input().split())

y2, m2, d2 = map(int, input().split())

        

k_age = y2 - y1 + 1

if (m1, d1) > (m2, d2):

    age = k_age - 2

else:

    age = k_age - 1

print(age)

print(k_age)

print(k_age - 1)

li = [input() for _ in range(4)]

if len(set(li)) == 1:

    print("Constant Depth")

elif list(sorted(li)) == li:

    print("Fish Rising")

elif list(sorted(li, reverse=True)) == li:

    print("Fish Diving")

else:

    print("No Fish")

BJ_2959 거북이 (Bronze III) 

a, b, c, d = sorted(map(int, input().split()))

print(a * c)

BJ_2997 네 번째 수 (Bronze III)

a, b, c = sorted(map(int,input().split()))

if b - a == c - b:

    print(2 * c - b)

elif b - a < c - b:

    print((b + c) // 2)

else:

    print((a + b) // 2)

BJ_2399 거리의 합 (Bronze II) 

# O(N logN) → Correct

N = int(input())

li = list(sorted(map(int, input().split())))

ret = 0

for i, e in enumerate(li):

    ret += (e * (2 * i - len(li) + 1) * 2)

print(ret)

BJ_2587 대표값2 (Bronze II) 

li = [int(input()) for _ in range(5)]

li.sort()

print(sum(li) // 5)

print(li[2])

BJ_3047 ABC (Bronze II)

li = list(sorted(map(int, input().split())))

dic = {'A' : 0, 'B' : 1, 'C' : 2}

order = input()

print(li[dic[order[0]]], li[dic[order[1]]], li[dic[order[2]]])

while True:

    a, b, c = sorted(map(int, input().split()))

    if a == 0:

        break

    if c ** 2 == a ** 2 + b ** 2:

        print("right")

    else:

        print('wrong')

BJ_2920 음계 (Bronze II)

li = list(map(int, input().split()))

if li == sorted(li):

    print("ascending")

elif li == sorted(li, reverse=True):

    print("descending")

else:

    print("mixed")

BJ_10867 중복 빼고 정렬하기 (Silver V) 

input()

print(*sorted(set(map(int, input().split()))))

BJ_11728 배열 합치기 (Silver V) 

input()

li1, li2 = list(map(int, input().split())), list(map(int, input().split()))

print(*sorted(li1 + li2))

BJ_11931 수 정렬하기 4 (Silver V) 

import sys

input = sys.stdin.readline

n = int(input())

li = [int(input()) for _ in range(n)]

for e in sorted(li, reverse=True):

    print(e)

BJ_15688 수 정렬하기 5 (Silver V) 

import sys

l = []

for _ in range(int(sys.stdin.readline())):

    l.append(int(sys.stdin.readline()))

print("\n".join(map(str, sorted(l))))

BJ_2693 N번째 큰 수 (Silver V) 

for _ in range(int(input())):

    print(sorted(map(int, input().split()))[-3])

BJ_11004 K 번째 수 (Silver V) 

k=int(input().split()[1])

print(sorted(map(int,input().split()))[k-1])

        

BJ_1427 소트인사이드 (Silver V) 

a = input()

print("".join(sorted(a, reverse=True)))

 

BJ_2750 수 정렬하기 (Silver V) 

a = int(input())

li = []

for _ in range(a):

    li.append(int(input()))

li.sort()                # same as  li = sorted(li)

for n in li:

    print(n)

BJ_11650 Sort coordinate (Silver V) 

n = int(input())

li = []

for _ in range(n):

    a, b = map(int, input().split())

    li.append((a, b))

for a, b in sorted(li):

    print(a, b)

BJ_11651 Sort coordinate 2 (Silver V) 

n = int(input())

li = []

for _ in range(n):

    a, b = map(int, input().split())

    li.append((b, a))

for a, b in sorted(li):

    print(b, a)

BJ_1181 단어 정렬 (Silver V) 

n_test = int(input())

se = set()

for _ in range(n_test):

    se.add(input())

for w in sorted(se, key=(lambda x: (len(x), x))):

    print(w)

BJ_10814 나이 순 정렬 (Silver V)

        import sys

n_test = int(sys.stdin.readline())

li = []

for _ in range(n_test):

    age, name = input().split()

    li.append((int(age), name))

for age, name in sorted(li, key=(lambda x: x[0])):

    print(age, name)

BJ_10989 수 정렬하기 3 (Silver IV) 

import sys

a = int(input())

dic = {}

for _ in range(a):

    n = int(sys.stdin.readline())

    if n in dic:

        dic[n] += 1

    else:

        dic[n] = 1

for n in sorted(dic.keys()):

    for _ in range(dic[n]):

        print(n)

BJ_10825 국영수 (Silver IV)

li = []

for _ in range(N):

    name, a, b, c = input().split()

    li.append(tuple((-int(a), int(b), -int(c), name)))

for e in sorted(li):

    print(e[3])

from collections import Counter

n, c = map(int, input().split())

li = input().split()

co = Counter(li)

print(" ".join(sorted(li, key=co.get, reverse=True)))

BJ_1213 팰림드롬 만들기 (Silver IV)

from collections import Counter

s = input()

co = Counter(s)

odds = [k for k in co if co[k] % 2 != 0]

if 1 < len(odds):

    print("I'm Sorry Hansoo")

else:    

    ret = ""

    for k in sorted(co):

        ret += k * (co[k] // 2)

    print(ret + ("" if len(odds) == 0 else odds[0]) + ret[::-1])    

BJ_18870 좌표 압축 (Silver II) 

N = int(input())

li = list(map(int, input().split()))

i2comp = {n : i for i, n in enumerate(list(sorted(set(li))))}

print(*[i2comp[i] for i in li])

        

        BJ_5052 전화번호 목록 (Gold IV) 

for _ in range(int(input())):

    n = int(input())

    li = [input() for _ in range(n)]

    li.sort()

    for i, j in zip(li, li[1:]):

        if i == j[:len(i)]:

            print("NO")

            break

    else:

        print("YES")

LC_278 First bad version 

def firstBadVersion(self, n):

    lo, hi = 1, n

    while lo < hi:

        mi = (lo + hi) // 2

        if not isBadVersion(mi):

            lo = mi + 1

        else:

            hi = mi

    return lo

KT_kornislav (1.4) 

숫자 4개가 주어진다. 이때 만들 수 있는 가장 큰 직사각형을 구하여라. (긴 변은 직사각형을 나가도 됨)

a, b, c, d = sorted(map(int, input().split()))

print(a * c)

KT_cups (1.5) 

n개 줄에

색 반지름 / 지름 색

둘 중 하나의 포맷으로 주어진다.

이 색들을 작은 반지름 순서대로 출력하라.

n_line = int(input())

li = []

for _ in range(n_line):

    a, b = input().split()

    if a.isdigit():

        li.append((int(a), b))

    else:

        li.append((int(b) * 2, a))

for _, color in sorted(li):

    print(color)

KT_schoolspirit (1.5) 

n_team = int(input())

li = list(sorted([int(input()) for _ in range(n_team)], reverse=True))

score = 0

for i, n in enumerate(li):

    score += n * (0.8 ** i)

print(score / 5)

score = 0

for i, n in enumerate(li):

    up = i

    stay = (n_team - 1 - i)

    score += n * (up * (0.8 ** (i - 1)) + stay * (0.8 ** i))

print(score / 5 / n_team)

KT_lineup (1.6) 

첫줄에 N 그 다음 N 줄에 사람 이름이 주어진다.

이 때 사람 이름이 알파벳 순서 일시 INCREASING,

알파벳 역순 일시 DECREASING,

둘 다 아니면 NEITHER을 출력하라.

n = int(input())

li = []

for _ in range(n):

    li.append(input())

if li == sorted(li):

    print("INCREASING")

elif li == sorted(li, reverse=True):

    print('DECREASING')

else:

    print('NEITHER')

tuple, zip

print(''.join(tuple(['1', '2'])))

print(''.join(tuple("abc")))

print((5, 4) < (5, 3))

print(('b', 4) < ('c', 3))

print((1, 2, 3) < (1, 2))

print((1, 2) == (1, 2))

print(sorted([(100, 'tom'), (90, 'sean')])[0][1])

# print(tuple([1, 2]) < tuple(['a', 1]))

for a, b in zip([1, 2], [3, 4]):

    print(a, b, end='-')

for a in enumerate([1, 2]):

    print(a[0], a[1])

BJ_2747 피보나치 수 (Bronze III) 

n = int(input())

a, b = 1, 0

for i in range(n):

    a, b = b, a + b

print(b)

BJ_2511 카드놀이 (Bronze III)

a_scores = list(map(int,input().split()))

b_scores = list(map(int,input().split()))

a_point = b_point = 0

last = 'D'

for a_score, b_score in zip(a_scores, b_scores):

    if a_score > b_score:

        last = 'A'

        a_point += 3

    elif a_score < b_score:

        last = 'B'

        b_point += 3

    else:

        a_point += 1

        b_point += 1

print(a_point, b_point)

if a_point > b_point:

    print("A")

elif b_point < a_point:

    print("B")

else:

    print(last)

BJ_2738 행렬 덧셈 (Bronze I) 

N, _ = map(int, input().split())

G1, G2 = [], []

for _ in range(N):

    G1.append(list(map(int, input().split())))

for _ in range(N):

    G2.append(list(map(int, input().split())))

   

for l1, l2 in zip(G1, G2):

    for a, b in zip(l1, l2):

        print(a + b, end=' ')

    print()

BJ_1026 보물 (Silver IV) 

n = int(input())

li1 = sorted(map(int, input().split()))

li2 = sorted(map(int, input().split()), reverse=True)

ret = 0

for n1, n2 in zip(li1, li2):

    ret += n1 * n2

print(ret)

KT_transitwoes (1.4) 

첫줄에 출발시간s, 수업시작시간t, n이 주어진다. 두번째 줄에는 n+1개의 수가 주어지며 한 정거장에서 다음정거장으로 가는데 걸리는 시간을 의미.

세번째 줄에는 n개의 수가 주어지며 버스타고가면서 걸리는시간을 의미.

네번째 줄에도 n 개의 수가 주어진다.버스가 정거장에 도착하는데 걸리는시간

제시간에 수업에 도착할 수 있으면 ‘yes’ 없으면 ‘no’를 출력하라

cur, t, n = map(int, input().split())

D = list(map(int, input().split()))

B = list(map(int, input().split()))

C = list(map(int, input().split()))

for d, b, c in zip(D, B, C):

    cur += d

    cur += (cur % c)

    cur += b

if cur + D[-1] < t:

    print("yes")

else:

    print("no")

KT_speedlimit (1.4) 

첫줄에 N 그 다음 N개의 줄에 speed / hour 와 달린 시간이 나온다. 이때 평균 속력을 출력하라.

(입력값 N이 -1일때까지)

n_line = int(input())

def total_miles(speeds, times):

    total_miles = 0

    prev_time = 0

    for speed, time in zip(speeds, times):

        total_miles += (time - prev_time) * speed

        prev_time = time

    return total_miles    

   

while n_line != -1:

    speeds, times = [], []

    for _ in range(n_line):

        speed, time = map(int, input().split())

        speeds.append(speed)

        times.append(time)

    print(f'{total_miles(speeds, times)} miles')    

    n_line = int(input())

KT_exam (1.9) 

첫줄에는 친구가 맞은 문제 수가, 둘째 줄 세째 줄에는 나와 친구의 답안이 주어진다.

내가 맞을 수 있는 최대 문제 수를 출력하라.

correct = int(input())

my = input()

fr = input()

total = len(my)

same = 0

for m, f in zip(my, fr):

    if m == f:

        same += 1

       

if same > correct:

    print(correct + (total - same))

else:

    print(same + (total - correct))

KT_detaileddifferences (1.4) 

두 문자가 주어질 때 그 문자를 출력하고

같은 자리는 . 다른 자리는 *를 아래에 출력하라.

N = int(input())

for _ in range(N):

    st1 = input()

    st2 = input()

    print(st1)

    print(st2)

    for c1, c2 in zip(st1, st2):

        if c1 == c2:

            print('.', end='')

        else:

            print('*', end='')

    print()

LC_48 rotate-image (medium) 

class Solution:

    def rotate(self, A):

        A[:] = zip(*A[::-1])

Binary | bisect | QSelect

BJ_15641 SUPER SUPER (Bronze V) 

BJ_1920 수 찾기 (Silver IV)

input()

li = list(sorted(map(int, input().split())))

input()

def binary_search(li, x):

    lo, hi = 0, len(li) - 1

    while lo < hi:

        mi = (hi + lo) // 2

        if li[mi] < x:

            lo = mi + 1

        elif li[mi] > x:

            hi = mi - 1

        else:

            return 1

    return li[lo] == x

for n in map(int, input().split()):

    print(1 if binary_search(li, n) else 0)

BJ_1654 랜선 자르기 (Silver III)

n, pieces = map(int, input().split())

li = []

for _ in range(n):

    li.append(int(input()))

def count(li, length):

    ret = 0

    for n in li:

        ret += n // length

    return ret

def binary_search(li, x):

    lo, hi = 0, max(li)

    while lo < hi:

        mi = (hi + lo + 1) // 2

        if count(li, mi) < x:

            hi = mi - 1

        else:

            lo = mi

    return lo        

print(binary_search(li, pieces))

BJ_2805 나무 자르기 (Silver III)

_, length = map(int, input().split())

li = list(map(int, input().split()))

def total(li, cut):

    ret = 0

    for n in li:

        ret += max(0, n - cut)

    return ret

def binary_search(li, x):

    lo, hi = 0, max(li)

    while lo < hi:

        mi = (hi + lo + 1) // 2

        if total(li, mi) < x:

            hi = mi - 1

        else:

            lo = mi

    return lo        

print(binary_search(li, length))

BJ_1072 게임 (Silver III)

total, win = map(int, input().split())

z = int(100 * win / total)

if z >= 99:

    print(-1)

else:

    lo, hi = 0, 1000000000

    while lo < hi:

        mi = (lo + hi) // 2

        if z < 100 * (win + mi) // (total + mi):

            hi = mi

        else:

            lo = mi + 1

    print(lo)

BJ_2696 중앙값 구하기 (Gold III) 

from bisect import insort

for _ in range(int(input())):

    m = int(input())

    print(str((m+1)//2))

    nums = []

    for t in range((m + 9) // 10):

        for i, n in enumerate(map(int,input().split())):

            insort(nums,n)

            if i % 2 == 0:

                print(nums[len(nums) // 2], end=' ')

        if t % 2 == 1:

            print()

    if t%2==0:

        print()

BJ_11053 가장 긴 증가하는 부분수열 (Silver II) 

BJ_12015 가장 긴 증가하는 부분수열 2 (Gold II) 

BJ_12738 가장 긴 증가하는 부분수열 3 (Gold II)

import bisect

input()

D = []

for e in map(int,input().split()):

    if len(D) == 0 or e > D[-1]:

        D += [e]

    else:

        D[bisect.bisect_left(D, e)] = e

print(len(D))

BJ_3745 오름세 (Gold III) 

import sys

import bisect

li = sys.stdin.readlines()

for i in range(0, len(li), 2):

    D = []

    for e in map(int, li[i + 1].split()):

        if len(D) == 0 or e > D[-1]:

            D += [e]

        else:

            D[bisect.bisect_left(D, e)] = e

    print(len(D))

# Top K most frequent elements

def topKFrequent(self, nums, k):

    frq = defaultdict(list)

    for key, cnt in Counter(nums).items():

        frq[cnt].append(key)

    res = []

    for times in reversed(range(len(nums) + 1)):

        res.extend(frq[times])

        if len(res) >= k: return res[:k]

    return res[:k]

LC_215 kth-largest-element-in-an-array/ 

def findKthLargest(self, li, k):

    pivot = random.choice(li)

    lo  = [l for l in li if l < pivot]

    mi = [e for e in li if e == pivot]

    hi = [r for r in li if r > pivot]

    if k <= len(hi):

        return self.findKthLargest(hi, k)

    elif (k - len(hi)) <= len(mi):

        return mi[0]

    else:

        return self.findKthLargest(lo, k - len(hi) - len(mi))

[7] Tricks

function | class

What is a function?

BJ_5575 타임 카드 (Bronze IV)

def worked(li):

    total = li[3] * 3600 + li[4] * 60 + li[5] - li[0] * 3600 - li[1] * 60 - li[2]

    print(total // 3600, total % 3600 // 60, total % 60)

   

worked(list(map(int, input().split())))

worked(list(map(int, input().split())))

worked(list(map(int, input().split()))) 

eval | try

BJ_2935 소음 (Bronze III)

print(eval(input()+input()+input()))

BJ_13420 사칙연산 

for _ in range(int(input())):

    eq, ans = input().split('=')

    print("correct" if eval(eq) == int(ans) else "wrong answer")

        BJ 5613 계산기 프로그램 (Bronze III)

c = input()

while 1:

    line = input()

    if line == '=':

        print(c)

        break

    b = input()

    c = int(eval(str(c) + line + b))

sys | copy

BJ_10951 A+B - 4 (Bronze III) 

import sys

for line in sys.stdin:

    print(sum(map(int,line.split())))

BJ_15552 빠른 A+B (Bronze II)

import sys

input = sys.stdin.readline

n_test = int(input())

for _ in range(n_test):

    a, b = map(int, input().split())

    print(a + b)

BJ_11719 그대로 출력하기 2 (Bronze I)

import sys

print(sys.stdin.read())

BJ_1247 부호 (Bronze III) 

import sys

for _ in range(3):

    N = int(input())

    li = [int(sys.stdin.readline()) for _ in range(N)]

    total = sum(li)

    if total > 0:

        print('+')

    elif total < 0:

        print('-')

    else:

        print(0)

BJ_5523 경기 결과 (Bronze III) 

import sys

input = sys.stdin.readline

N = int(input())

li = []

a_win, b_win = 0, 0

for _ in range(N):

    a, b = map(int, input().split())

    if a > b:

        a_win += 1

    elif b > a:

        b_win += 1

       

print(a_win, b_win)

BJ_4375 1 (Silver III) 

import sys

for line in sys.stdin:

    st = '1'

    while True:

        if int(st) % int(line) == 0:

            print(len(st))

            break

        st += '1'

BJ_6581 HTML (Silver I) 

import sys

lines = sys.stdin.read().split()

for i, line in enumerate(lines):

    if line == "<br>":

        print()

    elif line == "<hr>":

        if i != 0 and lines[i-1] not in ("<br>", "<hr>"):

            print()

        print("-" * 80)

    else:

        print(line, end=" ")

BJ_3060 욕심쟁이 돼지 (Silver V)

from copy import copy

for _ in range(int(input())):

    total = int(input())

    li = list(map(int, input().split()))

    for d in range(1, 100000):

        if sum(li) > total:

            print(d)

            break

        old = copy(li)

        for i in range(6):

            li[i] = old[i] + old[(i + 1) % 6] + old[(i + 3) % 6] + old[(i + 5) % 6]

Decimal | random | re

BJE_15858 Simple Arithmetic (Bronze III) 

from decimal import *

a,b,c=map(Decimal,input().split())

print(a*b/c)

BJ_15792 A/B - 2 (Bronze III)

from decimal import *

getcontext().prec = 10000

a, b = map(Decimal, input().split())

print(f"{a / b:.1000f}")

 

        BJ_10827 a^b (Silver I) 

        from decimal import *

getcontext().prec = 1200

a, b = list(map(Decimal, input().split()))

print(format(a ** b, 'f'))

LC_470 implement-rand10-using-rand7 (Medium) 

class Solution:

    def rand10(self):

        rand40 = 40

        while rand40 >= 40:

            rand40 = (rand7() - 1) * 7 + rand7() - 1

        return rand40 % 10 + 1

LC_478 generate-random-point-in-a-circle (Medium) 

import math

import random

class Solution:

    def __init__(self, radius, x_center, y_center):

        self.radius = radius

        self.x_center = x_center

        self.y_center = y_center

        random.seed()

    def randPoint(self):

        degree = random.uniform(0, 2 * math.pi)

        dist = (2 * random.uniform(0, self.radius ** 2 / 2.0)) ** (1/2.0)

        x = dist * math.cos(degree)

        y = dist * math.sin(degree)

        return [self.x_center + x, self.y_center + y]

BJ_9342 염색체 (Bronze I) 

import re

for _ in range(int(input())):

    print("Infected!" if re.match('^[A-F]?A+F+C+[A-F]?$', input()) else "Good")

BJ_8595 히든 넘버 

import re

input()

print(sum([int(d) for d in re.findall('\d+', input())]))

[8] Advanced Data structure

queue | stack | deque | heapq

BJ_4949 균형잡힌 세상 (Silver IV) 

while True:

    line = input()

    if line == '.':

        break

    stk = []

    for ch in line:

        if ch == '(' or ch == '[':

            stk.append(ch)

        elif ch == ')':

            if not stk or stk[-1] == '[':

                print("no")

                break

            elif stk[-1] == '(':

                stk.pop()

        elif ch == ']':

            if not stk or stk[-1] == '(':

                print("no")

                break

            elif stk[-1] == '[':

                stk.pop()

    else:

        print("no" if stk else "yes")

BJ_10799 쇠막대기 (Silver III) 

bar_razor = list(input())

answer = 0

stk = []

for i in range(len(bar_razor)):

    if bar_razor[i] == '(':

        stk.append('(')

    else:

        if bar_razor[i - 1] == '(':

            stk.pop()

            answer += len(stk)

        else:

            stk.pop()

            answer += 1

print(answer)

BJ_1725 히스토그램 (Gold I) 

def largest_rect(heights):

    hws, mx_area = [], 0

    for i, h in enumerate(heights):

        width = 0

        while len(hws) and h < hws[-1][0]:

            width += hws[-1][1]

            mx_area = max(mx_area, width * hws[-1][0])

            hws.pop()

        hws.append([h, width + 1])

    while hws:

        width += hws[-1][1]

        mx_area = max(mx_area, width * hws.pop()[0])

    return mx_area

   

line = int(input())

heights = [int(input()) for _ in range(line)]

print(largest_rect(heights))

BJ_6549 히스토그램에서 가장 큰 직사각형 (Platinum V) 

def largest_rect(heights):

    hws, mx_area = [], 0

    for i, h in enumerate(heights):

        width = 0

        while len(hws) and h < hws[-1][0]:

            width += hws[-1][1]

            mx_area = max(mx_area, width * hws[-1][0])

            hws.pop()

        hws.append([h, width + 1])

    while hws:

        width += hws[-1][1]

        mx_area = max(mx_area, width * hws.pop()[0])

    return mx_area

   

while True:

    line = input()

    if line == '0':

        break

    heights = list(map(int, line.split()))[1:]

    print(largest_rect(heights))

BJ_10866 덱 (Silver IV) 

import sys

from collections import deque

input = sys.stdin.readline

N = int(input())

dq = deque()

for i in range(N):

    cmd = list(input().split())

    if cmd[0] == 'push_front':

        dq.appendleft(cmd[1])

    elif cmd[0] == 'push_back':

        dq.append(cmd[1])

    elif cmd[0] == 'pop_front':

        print("-1" if len(dq) == 0 else dq.popleft())

    elif cmd[0] == 'pop_back':

        print("-1" if len(dq) == 0 else dq.pop())

    elif cmd[0] == 'front':

        print("-1" if len(dq) == 0 else dq[0])

    elif cmd[0] == 'back':

        print("-1" if len(dq) == 0 else dq[-1])

    elif cmd[0] == 'size':

        print(len(dq))

    elif cmd[0] == 'empty':

        print(1 if len(dq) == 0 else 0 )

BJ_10773 제로 (Silver IV)

import sys

from collections import deque

input = sys.stdin.readline

dq = deque()

for _ in range(int(input())):

    num = int(input())

    if num == 0:

        dq.pop()

    else:

        dq.append(num)

print(sum(dq))

BJ_2164 카드 2 (Silver IV) 

from collections import deque

deck = deque(range(1, int(input()) + 1))

while len(deck) > 1:

    deck.popleft()

    deck.append(deck.popleft())

print(deck[0])

 

BJ_2605 줄 세우기 (Bronze II)

from collections import deque

N = int(input())

student = list(map(int, input().split()))

result = deque()

for i, move in enumerate(student):

    result.rotate(move)

    result.append(i + 1)

    result.rotate(-move)

print(*result)

BJ_1966 프린터 큐 (Silver III) 

from collections import deque

for _ in range(int(input())):

    N, M = map(int, input().split())

    weight = deque(map(int, input().split()))

    index = deque(range(N))

   

    res = 1

    while True:

        if index[0] == M and weight[0] == max(weight):

            break

        else:

            if weight[0] == max(weight):

                weight.popleft()

                index.popleft()

                res += 1

            else:

                weight.append(weight.popleft())

                index.append(index.popleft())

    print(res)

BJ_18258 큐 2 (Silver IV) 

from collections import deque

import sys

N = int(input())

samples = deque()

for _ in range(N):

    tokens = sys.stdin.readline().split()

    if tokens[0] == 'push':

        samples.append(tokens[1])

    elif tokens[0] == 'pop':

        print(samples.popleft() if samples else -1)

    elif tokens[0] ==  'size':

        print(len(samples))

    elif tokens[0] == 'empty':

        print(0 if samples else 1)

    elif tokens[0] == 'front':

        print(samples[0] if samples else -1)

    elif tokens[0] == 'back':

        print(samples[-1] if samples else -1)

BJ_11279 최대 힙 (Silver II) 

import heapq

import sys

input = sys.stdin.readline

heap = []

for _ in range(int(input())):

    num = int(input())

    if num != 0:

        heapq.heappush(heap, (-num))

    else:

        if len(heap):

            print(-1 * heapq.heappop(heap))

        else:

            print(0)

BJ_1927 최소 힙 (Silver I) 

input()

li = list(map(int,input().split()))

if max(li) <= 0:

    print(max(li))

else:

    cur_sum = 0

    max_sum = 0

    for n in li:

        cur_sum += n

        if cur_sum < 0:

            cur_sum = 0

        max_sum = max(cur_sum, max_sum)

    print(max_sum)

BJ_7662 이중 우선순위 큐 (Gold V) 

import sys

import heapq

input=sys.stdin.readline

for _ in range(int(input())):

    numbers = set()

    minH, maxH = [],[]

    for i in range(int(input())):

        s=input().split()

        if s[0]=='I':

            heapq.heappush(minH,(int(s[1]),i))

            heapq.heappush(maxH,(-int(s[1]),i))

            numbers.add(i)

        elif s[1]=='1':

            while maxH and not maxH[0][1] in numbers:

                heapq.heappop(maxH)

            if maxH:

                numbers.remove(maxH[0][1])

                heapq.heappop(maxH)

        else:

            while minH and not minH[0][1] in numbers:

                heapq.heappop(minH)

            if minH:

                numbers.remove(minH[0][1])

                heapq.heappop(minH)

    while minH and minH[0][1] not in numbers:

        heapq.heappop(minH)

    while maxH and maxH[0][1] not in numbers:

        heapq.heappop(maxH)

    print(f'{-maxH[0][0]} {minH[0][0]}' if maxH and minH else 'EMPTY')

BJ_1922 네트워크 연결 (Gold IV) 

import heapq

n,  m = int(input()), int(input())

G = [[] for _ in range(n)]

for _ in range(m):

    s, e, c = map(int, input().split())

    G[s-1].append([e-1, c])

    G[e-1].append([s-1, c])

key = [0] + [float('inf')] * (n - 1)

visited = [False] * n

pq = []

heapq.heappush(pq, (0, 0))

result = 0

while pq:

    k, u = heapq.heappop(pq)

    if visited[u]:

        continue

    visited[u] = True

    result += k

    for dest, w in G[u]:

        if not visited[dest] and w < key[dest]:

            key[dest] = w

            heapq.heappush(pq, (key[dest], dest))

print(result)

BJ_17612 쇼핑몰 (Gold I) 

import sys

from heapq import *

input = sys.stdin.readline

n,k = map(int,input().split())

pq = [(0, i) for i in range(k)]

arr, ids = [],[]

for i in range(n):

    id_,buy = map(int,input().split())

    time, kiosk = heappop(pq)

    heappush(pq,(time + buy, kiosk))

    arr.append((time + buy, kiosk, i+1))

    ids.append(id_)

arr.sort(key=lambda x:(x[0],-x[1]))  

s = 0

for i in range(n):

    s += ids[arr[i][2] - 1] * (i + 1)

print(s)

list | graph

LC_21 merge-two-sorted-lists (Easy) 

class Solution:

    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:

        dummy = cur = ListNode(0)

        while l1 and l2:

            if l1.val < l2.val:

                cur.next = l1

                l1 = l1.next

            else:

                cur.next = l2

                l2 = l2.next

            cur = cur.next

        cur.next = l1 or l2

        return dummy.next

LC_61 rotate-list (medium) 

class Solution:

    def rotateRight(self, head: ListNode, k: int) -> ListNode:

        if not head:

            return None

        old_last = head

        length = 1

        while old_last.next:

            old_last = old_last.next

            length += 1

        k = k % length

        old_last.next = head

        new_last = head

        for _ in range(length - k - 1):

            new_last = new_last.next

        answer = new_last.next

        new_last.next = None

        return answer

LC_2 add-two-numbers (medium) 

class Solution:

    def addTwoNumbers(self, l1, l2):

        carry = 0;

        res = n = ListNode(0);

        while l1 or l2 or carry:

            if l1:

                carry += l1.val

                l1 = l1.next;

            if l2:

                carry += l2.val;

                l2 = l2.next;

            carry, val = divmod(carry, 10)

            n.next = n = ListNode(val);

        return res.next

LC_19 remove-nth-node-from-end-of-list (medium) 

class Solution:

    def removeNthFromEnd(self, head, n):

        fast = slow = head

        for _ in range(n):

            fast = fast.next

        if not fast:

            return head.next

        while fast.next:

            fast = fast.next

            slow = slow.next

        slow.next = slow.next.next

        return head

LC_109 convert-sorted-list-to-binary-search-tree (Medium) 

class Solution:

    def sortedListToBST(self, head):

        if not head:

            return

        if not head.next:

            return TreeNode(head.val)

       

        slow, fast = head, head.next.next

        while fast and fast.next:

            fast = fast.next.next

            slow = slow.next

        tmp = slow.next

       

        slow.next = None

        root = TreeNode(tmp.val)

        root.left = self.sortedListToBST(head)

        root.right = self.sortedListToBST(tmp.next)

        return root

Walk                        # Vertices may repeat. Edges may repeat (Closed or Open)

Trail                        # Vertices may repeat. Edges cannot repeat (Open)

Circuit                        # Vertices may repeat. Edges cannot repeat (Closed)

Path                        # Vertices cannot repeat. Edges cannot repeat (Open)

Cycle                        # Vertices cannot repeat. Edges cannot repeat (Closed)

Hamiltonian                # Visits every vertex in the graph

Eulerian                # Visits every edge in the graph

# Directed

DAGs                         # Directed acyclic graphs are directed graphs with no cycle

Weakly Connected         # Undirected version of directed graph is connected

Strongly Connected         # Directed graph G is strongly connected a path exists for all ordered pair vertices

SCC                        # Strongly connected components is maximal strongly connected piece

# Undirected

Connected                # G is connected if for any pair of vertices v, w there is a path from v to w

        CC                        Connected components is maximal connected piece

85ME_graph (edit) 

85ME_graph 

What is indegree of 2?

Is the cycle in the graph? (T/F)

Is the graph directed? (T/F)

Shortest Path from 0 to 5

How many edges are there?

What is indegree of 5?

How many vertices are there?

What is the biggest edge in the graph?

What is the smallest cycle sum?

What is the outdegree of 0?

Tree edge                # solid edge included in the DFS output tree         (pre u < pre v < post v < post u)

Back edge                # leads to an ancestor                                 (pre v < pre u < post u < post v)

Cross edge                # leads to neither anc. or des                         (pre v < post v < pre u < post(u)

Tree | Segment | BIT | RB

What is the root?

How many vertices are there?

How many children does node 2 have?

What is the parent of 6?

How many leaves are there?

What is the depth of 10?

How many children does node 7 have?

How many edges are there?

What is the depth of the tree?

How many vertices have 2 children?

        Lazy Propagation

BJE_10090 Counting Inversion (Gold I)

class SegmentTree:

    def __init__(self, nums):

        self.N = len(nums)

        self.tree = [0] * self.N + nums

        for i in range(self.N - 1, 0, -1):

            self.tree[i] = self.tree[i<<1] + self.tree[i<<1|1]

    def update(self, i, val):

        n = self.N + i

        self.tree[n] = val

        while n > 1:

            self.tree[n>>1] = self.tree[n] + self.tree[n^1]

            n >>= 1

    def sumRange(self, i, j):

        m, n = self.N + i, self.N + j

        res = 0

        while m <= n:

            if m & 1:

                res += self.tree[m]

                m += 1

            m >>= 1

            if n & 1 ==0:

                res += self.tree[n]

                n -= 1

            n >>= 1

        return res

N, res = int(input()), 0

st = SegmentTree([0] * (N + 1))

for n in map(int, input().split()):

    st.update(n, 1)

    res += st.sumRange(n + 1, N)

print(res)

 

        BJ_2042 구간 합 구하기 (Platinum V)

class SegmentTree:

    def __init__(self, nums):

        self.N = len(nums)

        self.tree = [0] * self.N + nums

        for i in range(self.N - 1, 0, -1):

            self.tree[i] = self.tree[i<<1] + self.tree[i<<1|1]

    def update(self, i, val):

        n = self.N + i

        self.tree[n] = val

        while n > 1:

            self.tree[n>>1] = self.tree[n] + self.tree[n^1]

            n >>= 1

    def sumRange(self, i, j):

        m, n = self.N + i, self.N + j

        res = 0

        while m <= n:

            if m & 1:

                res += self.tree[m]

                m += 1

            m >>= 1

            if n & 1 ==0:

                res += self.tree[n]

                n -= 1

            n >>= 1

        return res

N, M, K = map(int, input().split())

st = SegmentTree([int(input()) for _ in range(N)])

for i in range(M + K):

    typ, a, b = map(int, input().split())

    if typ == 1:

        st.update(a - 1, b)

    else:

        print(st.sumRange(a - 1, b - 1))

BJ_2357 최솟값과 최댓값 (Platinum V) 

import sys,math

class SegTree:

    def __init__(self, a,hi):

        self.tree=[9000000000]*(hi<<1)

        self.maxt=[0]*(hi<<1)

        self.h = hi

        self.tree[hi:hi+len(a)] = self.maxt[hi:hi+len(a)] = a

        for i in range(hi-1,0,-1):

            t=i<<1

            m=0

            a=self.tree[t]

            b=self.tree[t+1]

            if a>b:m=b

            else:m=a

            self.tree[i]=m

            a=self.maxt[t]

            b=self.maxt[t+1]

            if a<b:m=b

            else:m=a

            self.maxt[i]=m

    def q(self,left,right):

        min_r=[]

        max_r=[]

        left+=h

        right+=h

        while left<right:

            if left%2:

                min_r+=[self.tree[left]]

                max_r+=[self.maxt[left]]

                left+=1

            if right%2==0:

                min_r+=[self.tree[right]]

                max_r+=[self.maxt[right]]

                right-=1

            left//=2

            right//=2

        if left==right:

            min_r+=[self.tree[left]]

            max_r+=[self.maxt[left]]

        return [min(min_r),max(max_r)]

input=sys.stdin.readline

n,m=map(int,input().split())

p=[int(input())for i in range(n)]

h=1<<math.ceil(math.log2(n))

tree=SegTree(p,h)

for i in sys.stdin:

    a,b=map(int,i.split())

    print(*tree.q(a-1,b-1))

BJ_1395 스위치 (Platinum III) 

import sys

 

input = sys.stdin.readline

class SegmentTree:

    def __init__(self, n):

        self.h = n.bit_length()

        self.seg = [0] * 2*n

        self.lazy = [0] * n

        self.size = [1] * 2*n

        for i in reversed(range(1, n)):

            self.size[i] = 2 * self.size[2*i]

    def apply(self, p):

        self.seg[p] = self.size[p] - self.seg[p]

        if p < n:

            self.lazy[p] ^= 1

    def up(self, p):

        while p > 1:

            p >>= 1

            self.seg[p] = self.seg[2*p] + self.seg[2*p + 1]

            if self.lazy[p] == 1:

                self.seg[p] = self.size[p] - self.seg[p]

    def down(self, p):

        for i in reversed(range(1, self.h + 1)):

            pp = p >> i

            if self.lazy[pp] != 0:

                self.apply(2*pp)

                self.apply(2*pp + 1)

                self.lazy[pp] = 0

    def update(self, l, r):

        l += n

        r += n

        l0, r0 = l, r

        while l < r:

            if l & 1:

                self.apply(l)

                l += 1

            if r & 1:

                r -= 1

                self.apply(r)

            l >>= 1

            r >>= 1

        self.up(l0)

        self.up(r0 - 1)

    def query(self, l, r):

        l += n

        r += n

        self.down(l)

        self.down(r - 1)

        res = 0

        while l < r:

            if l & 1:

                res += self.seg[l]

                l += 1

            if r & 1:

                r -= 1

                res += self.seg[r]

            l >>= 1

            r >>= 1

        return res

n, m = map(int, input().split())

st = SegmentTree(n)

for _ in range(m):

    q = list(map(int, input().split()))

    if q[0] == 0:

        st.update(q[1] - 1, q[2])

    else:

        print(st.query(q[1] - 1, q[2]))


[10] Math

import

BJ_2869 달팽이는 올라가고 싶다 (Bronze II)

import math

a, b, c = map(int, input().split())

print(math.ceil((c - a) / (a - b)) + 1)

BJ_16486 운동장 한 바퀴 (Bronze IV)

import math

a, b = int(input()), int(input())

print(a * 2 + 2 * b * math.pi)

BJ_5532 방학 숙제 (Bronze IV) 

import math

n = int(input())

A = int(input())

B = int(input())

C = int(input())

D = int(input())

print(n - max(math.ceil(A / C), math.ceil(B / D)))

BJ_13136 Do Not Touch Anything (Bronze IV) 

import math

a, b, c = map(int, input().split())

print(math.ceil(a / c) * math.ceil(b / c))

BJ_2875 대회 or 인턴 (Bronze III)

import math

a, b, c = map(int, input().split())

team = min(a // 2, b)

c = max(0, c - (a - team * 2) - (b - team))

print(team - math.ceil(c / 3))

        

BJ_3053 택시 기하학 (Bronze III)

import math

n = int(input())

print(n * n * math.pi)

print(n * n * 2)

BJ_2309 일곱 난쟁이 (Bronze II)

import itertools

li = [int(input()) for _ in range(9)]

for l in itertools.combinations(li, 7):

    if sum(l) == 100:

        print(*sorted(l), sep='\n')

        break

BJ_2798 블랙잭 (Bronze II)

import itertools

n, m = map(int, input().split())

li = list(map(int, input().split()))

ret = 0

for l in itertools.combinations(li, 3):

    if ret < sum(l) <= m:

        ret = sum(l)

print(ret)

BJ_2010 플러그 (Bronze III)

import sys

input = sys.stdin.readline

n = int(input())

total = 0

for _ in range(n):

    total += int(input())

print(total - n + 1)

BJ_1934 최소공배수 (Silver V)

import math

t = int(input());

for _ in range(t):

    a,b = map(int, input().split())

    print(int(a * b / math.gcd(a,b)))

KT_herman (1.6)

첫째 줄에 n이 주어진다.

반지름이 n인 원의 넓이를 출력하라.

그 다음 줄에 n * n * 2 를 출력하라.

import math

n = int(input())

print(n * n * math.pi)

print(n * n * 2)

KT_ladder (1.4)

높이 h와 각도 theta가 주어질 때 사다리의 최소 길이를 구하여라. (ceil)

import math

a, theta = map(int, input().split())

print(math.ceil(a / math.sin(theta / 180 * math.pi)))

KT_oddmanout (1.5)

n_test개의 줄에 N과 N개의 정수가 주어진다.

이때 짝이 없는 정수를 출력하라.

n_test = int(input())

for test in range(1, n_test + 1):

    N = int(input())

    ret = 0

    for x in map(int, input().split()):

        ret ^= x

    print(f"Case #{test}: {ret}")

KT_humancannonball2 (1.4)          

import math

n_shot = int(input())

for _ in range(n_shot):

    v, theta, x, h1, h2 = map(float, input().split())

   

    hit_t = x / (v * math.cos(theta / 180 * math.pi))

    hit_y = v * hit_t * math.sin(theta / 180 * math.pi) - 9.8/2 * hit_t ** 2

   

    if h1 + 1 <= hit_y <= h2 - 1:

        print('Safe')

    else:

        print('Not Safe')

Exponent | Logarithm

Introduction to exponents

#

Negative exponents

#

#

Zero, negative, and fractional exponents

Introduction to square roots

Introduction to cube roots

26MH_Exponent (edit) 

26MH_Exponent

-2 ** 3

-5 ** -2

0**0

10**3

1000000**0

4**0.5

27**(1/3)

16**(3/4)

4**(-0.5)

8**(-2/3)

BJ_2475 검증수 (Bronze V) 

a, b, c, d, e = map(int, input().split())

print((a ** 2 + b ** 2 + c ** 2 + d ** 2 + e ** 2) % 10)

BJE_15610 Abbey Courtyard (Bronze IV) 

print(int(input()) ** 0.5 * 4)

BJ_1297 TV 크기 (Bronze IV) 

d, w, h = map(int, input().split())

x = (d ** 2 / (w ** 2 + h ** 2)) ** 0.5

print(int(x * w), int(x * h))

BJ_1009 분산 처리 (Bronze III) 

for i in range(int(input())):

    a,b = map(int,input().split())

    ans = pow(a,b,10)

    print(10 if ans == 0 else ans)

BJ_3034 앵그리 창영 (Bronze III)

n, w, h = map(int, input().split())

for _ in range(n):

    a = int(input())

    if  a ** 2 <= w ** 2 + h ** 2:

        print('DA')

    else:

        print('NE')

BJ_2903 중앙 이동 알고리즘 (Bronze III) 

a = int(input())

print((2 ** a + 1) ** 2)

a, b = map(int, input().split())

print(a ** b)

BJ_2052 지수 (Bronze III)

n = int(input())

print(f'{2 ** (-n):.{n}f}')

BJ_7510 고급 수학(Bronze III)

for i in range(int(input())):

    sides = sorted(map(int, input().split()))

    if sides[0] ** 2 + sides[1] ** 2 + sides[2] ** 2 == max(sides) ** 2 * 2:

        print(f'Scenario #{i + 1}:\nyes')

    else:

        print(f'Scenario #{i + 1}:\nno')

    print()

BJ_1834 나머지와 몫이 같은 수 (Bronze I)

N=int(input())

print((N**3-N)//2)

        

BJ_1676 팩토리얼 0의 개수 (Silver I)

N = int(input())

print(N//5 + N//25 + N//125)

 

KT_areal (1.5) 

정사각형의 목장이 있다.

목장의 넓이가 주어질 때 목장을 둘러싸는 fence의 길이를 구하라.

n = int(input())

print((n ** 0.5) * 4)

KT_tetration (1.6) 

첫 줄에 n 이 주어진다.

n^(1 / n) 을 출력하라.

n = float(input())

print(n ** (1/n))

KT_planina (1.3) 

다음과 같은 규칙이 있을때 n + 1번째 그림의 점의 개수를 구하여라

a = int(input())

print((2 ** a + 1) ** 2)

KT_3dprinter (1.9) 

from math import ceil, log

line = int(input())

print(int(ceil(log(line, 2) + 1)))

Bit | Operation

Introduction to number systems and binary

Converting from decimal to binary

Converting larger number from decimal to binary 

Adding in binary 

Multiplying in binary 

Hexadecimal number system 

Converting from decimal to hexadecimal representation 

Converting directly from binary to hexadecimal 

int('0b1111')                                        # 15                (2 → 10)

int('A0', 16)                                        # 160                 (16 → 10)

bin(11)                                                # '0b1011'        (10 → 2)

oct(15)                                                # '0o17'        (10 → 8)

hex(10)                                        # '0xA'                (10 → 16)

# table

print('2', '10', '16')

for i in range(50):

    print(bin(i)[2:], '\t', i, '\t', hex(i)[2:])

81ME_Bit|Operation (Edit) 

81ME_Bit|Operation

15 to Binary

12 to Hexadecimal

0b1011 + 0b1111 to binary

0b1011 to Hexadecimal

0x1BC0 to Decimal

0xBC to Binary

0o163 + 0o53 to Octet

0x12 // 0x6 to Decimal

0b1101 * 0b111 to Binary

4200 to Hexadecimal

BJ_1550 16 to 10 (Bronze V) 

print(int(input(), 16))

BJ_5893 17배 (Bronze IV) 

a = int(input(), 2)

print(bin(a * 17)[2:])

BJ_1212 8진수 2진수 (Bronze IV) 

n = int(input(), 8)

print(bin(n)[2:])

BJ_14623 감정이입 (Bronze IV) 

a, b = int(input(), 2), int(input(), 2)

print(bin(a * b)[2:])

BJ_11966 2의 제곱인가?(Bronze III)

n = int(input())

print(0 if (n & (n - 1)) else 1)

BJ 14491 9진수 (Bronze III) 

N = int(input())

ret = count = 0

while N > 0:

    ret += N % 9 * pow(10, count)

    count += 1

    N //= 9

print(ret)

BJ 13877 이건 무슨 진법이지? (Bronze III) 

for _ in range(int(input())):

    a, b = input().split()

    print(a, end = ' ')

    if '8' in b or '9' in b:

        print(0, end = ' ')

    else:

        print(int(b, 8), end = ' ')

    print(int(b, 10), int(b, 16))

BJ_1864 문어 숫자 (Bronze III) 

ch2int = {'-':0, '\\':1, '(':2, '@':3, '?':4, '>':5, '&':6, '%':7, '/':-1}

while True:

    string = input()

    if string == '#':

        break

    ret = 0

    for ch in string:

        ret *= 8

        ret += ch2int[ch]

    print(ret)

BJ_3460 이진수 (Bronze III) 

n = int(input())

for _ in range(n):

    x = int(input())

    n = 0

    while x != 0:

        if x & 1:

            print(n, end=' ')

        n += 1

        x //= 2

    print()

BJ_2745 진법 변환 (Bronze II) 

a, b = input().split()

print(int(a, int(b)))

BJ_6679 싱기한 네자리 숫자 (Bronze II) 

def sum_digit(dec, n):

    ret = 0

    while n != 0:

        ret += n % dec

        n //= dec

    return ret

   

for n in range(1000, 10000):

    if sum_digit(10, n) == sum_digit(12, n) == sum_digit(16, n):

        print(n)

BJ_10829 이진수 변환 (Bronze I) 

print(bin(int(input()))[2:])

       

BJ_11005 진법 변환 2 (Bronze I)

a, b = map(int, input().split())

conv = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

ret = ""

while a != 0:

    ret = conv[a % b] + ret

    a //= b    

print(ret)

BJ_11816 8진수, 10진수, 16진수 (Bronze I)

line = input()

if line[0] == '0':

    if line[1] == 'x':

        print(int(line, 16))

    else:

        print(int(line, 8))

else:

    print(line)

BJ_13701 중복 제거 (Gold III) 

import sys

import os

a = bytearray(2**22)

unstdin = os.fdopen(sys.stdin.fileno(), 'rb', 1000000)

while True:

    b = 0

    while True:

        ch = unstdin.read(1)

        if b'0' <= ch <= b'9':

            b = 10*b+int(ch)

        elif ch == b' ':

            break

        else:

            x, y = b % 8, b // 8

            if not a[y] & (1<<x):

                print(b, end = '')

            exit()

           

    x, y = b % 8, b // 8

    if not a[y] & (1<<x):

        print(b, end = ' ')

    a[y] |= (1<<x)

KT_oktalni (1.9)

2진법으로 들어 온 수를 8진법으로 출력하라.

num = int(input(), 2)

print(oct(num)[2:])

81CH_Bit | Operation(edit)

81CH_Bit | Operation

print(1 ^ 4)

print(4 ^ 6)

print(2 | 5)

print(3 | 6)

print(4 & 5)

        print(8 & 3)

        print(11 | 13)

print(7 & 5)

print(12 & 14)

print(13 ^ 10)

n&-n                                                # Get lowest set bit

(n&(n-1))==0                                        # Check power of two

BJ_3009 네 번째 점 (Bronze III) 

a, b = map(int, input().split())

c, d = map(int, input().split())

e, f = map(int, input().split())

print(a ^ c ^ e, b ^ d ^ f)

BJ 15917 노솔브 방지문제야!! (Bronze III) 

import sys

input = sys.stdin.readline

N = int(input())

for _ in range(N):

    a = int(input())

    if a&(-a) != a:

        print('0')

    else:

        print('1')

BJ_12833 XORXORXOR (Bronze III)

a, b, c = map(int, input().split())

for _ in range(c % 2):

    a ^= b

print(a)

BJ_18119 단어 암기 (Gold IV) 

import sys

input = sys.stdin.readline

n, m = map(int, input().split())

words = [0 for i in range(n)]

for i in range(n):

    for ch in input().rstrip():

        words[i] |= 1 << (ord(ch) - 97)

alpha = 0xffffffff

for _ in range(m):

    o, x = input().split()

    if o == '1':

        alpha &= ~(1 << ord(x)-97)

    elif o == '2':

        alpha |= (1 << ord(x)-97)

    print(sum(1 for word in words if (word & alpha) == word))

KT_cetvrta (1.4)

3개의 꼭짓점의 좌표가 주어질 때 나머지 한개의 꼭짓점의 좌표를 구하여라.

x1, y1 = map(int, input().split())

x2, y2 = map(int, input().split())

x3, y3 = map(int, input().split())

print(x1 ^ x2 ^ x3, y1 ^ y2 ^ y3)

LC_338 Counting-bits

def countBits(self, num) -> List[int]:

    ret = [0] * (num + 1)

    for i in range(num + 1):

        ret[i] = ret[i // 2] + i % 2

    return ret

! Counting | Comb | stat

숫자 1-6으로 만들 수 있는 3자리 숫자의 개수

숫자 1-6으로 만들 수 있는 3자리 짝수의 개수

소문자 알파벳 3자와 숫자 3 개로 만들 수 있는 아이디의 개수

BJ_16968 차량 번호판 1 (Bronze II) 

s = input()

ret = 1

for i, ch in enumerate(s):

    if ch == 'd':

        if i != 0 and s[i - 1] == 'd':

            ret *= 9

        else:

            ret *= 10

    else:

        if i != 0 and s[i - 1] == 'c':

            ret *= 25

        else:

            ret *= 26

print(ret)

BJ_16969 차량 번호판 2 (Bronze I) 

s = input()

ret = 1

for i, ch in enumerate(s):

    if ch == 'd':

        if i != 0 and s[i - 1] == 'd':

            ret *= 9

        else:

            ret *= 10

    else:

        if i != 0 and s[i - 1] == 'c':

            ret *= 25

        else:

            ret *= 26

    ret %= 1000000009

print(ret)

BJ_3049 다각형의 대각선 (Bronze III)

n = int(input())

print(n * (n - 1) * (n -2) * (n - 3) // 24)

BJ_11050 이항 계수1 (Bronze I)

import math

a, b = map(int, input().split())

print(math.comb(a, b))

BJ_1010 다리 놓기 (Silver V)

import math

N = int(input())

for _ in range(N):

    a, b = map(int, input().split())

    print(math.comb(b, a))

BJ_13251 조약돌 꺼내기 (Silver IV) 

from math import comb

N = int(input())

li = list(map(int, input().split()))

pick = int(input())

print(sum(comb(n, pick) for n in li) / comb(sum(li), pick))

BJ_6591 이항 쇼다운 (Silver III) 

import math

while True:

    a, b = map(int, input().split())

    if a == b == 0:

        break

    print(math.comb(a, b))

BJ_6603 로또 (Silver II) 

from itertools import combinations

while True:

    line = input()

    if line == "0":

        break

    li = line.split()[1:]

    for comb in combinations(li, 6):

        print(" ".join(comb))

    print()

BJ_14888 연산자 끼워넣기 (Silver I) 

from itertools import permutations

N = int(input())

A = list(map(int, input().split()))

a, s, m, d = map(int, input().split())

mn, mx = float('inf'), -float('inf')

for p in set(permutations('+'*a+'-'*s+'*'*m+'/'*d)):

    r = A[0]

    for i in range(1, N):

        r = {'+': r+A[i], '-': r-A[i], '*': r*A[i], '/': int(r/A[i])}[p[i-1]]

    mn = min(mn, r)

    mx = max(mx, r)

print(mx)

print(mn)

BJ_1759 암호 만들기 (Gold V) 

from itertools import combinations

n, m = map(int, input().split())

li = sorted(input().split())

for c in combinations(li, n):

    count = 0

    for letter in c:

        if letter in "aeiou":

            count += 1

    if (count >= 1) and (count <= n-2):

        print(*c, sep ='')

KT_sjecista (1.8)

n개의 꼭지점을 가진 다각형이 있다.

이 때 모든 선분의 교차점의 개수를 출력하라. 단 3개 이상의 선분은 한 점에서 만나지 않는다.

import math

def nCr(n,r):

    if r > n:

        return 0

    f = math.factorial

    return f(n) // f(r) // f(n-r)

n = int(input())

print(nCr(n, 4))

        import math

while True:

    a, b = map(int, input().split())

    if a == b == 0:

        break

    print(math.comb(a, b))

       

Range, variance and standard deviation as measures of dispersion 

Geometry | Trigonometry

BJE_16693 Pizza Deal (Bronze IV)

import math

a, p1 = map(int, input().split())

r, p2 = map(int, input().split())

if a * p2 < r * r * math.pi * p1:

    print('Whole pizza')

else:

    print('Slice of pizza')

BJ_14264 정육각형과 삼각형 (Bronze IV)

import math

s = int(input())

print(math.sin(60 * math.pi / 180) * s ** 2 / 2)

BJ_1485 정사각형 (Silver IV)

def dist(p1, p2):

    ax, ay = p1

    bx, by = p2

    return (ax - bx) ** 2 + (ay - by) ** 2

for _ in range(int(input())):

    P = [tuple(map(int,input().split())) for i in range(4)]

    P.sort()

    ans = dist(P[0], P[3]) == dist(P[1], P[2]) and dist(P[0], P[1]) == dist(P[0], P[2])

    print(int(ans))

BJ_11758 CCW (Gold V) 

def ccw(x1, y1, x2, y2, x3, y3):

    total = (x2-x1) * (y3-y1) - (y2-y1) * (x3-x1)

    return (total > 0) - (total < 0)

x1, y1 = map(int, input().split())

x2, y2 = map(int, input().split())

x3, y3 = map(int, input().split())

print(ccw(x1, y1, x2, y2, x3, y3))

BJ_17386 선분 교차 1 (Gold III)

def ccw(x1, y1, x2, y2, x3, y3):

    total = (x2-x1) * (y3-y1) - (y2-y1) * (x3-x1)

    return (total > 0) - (total < 0)

x1, y1, x2, y2 = map(int, input().split())

x3, y3, x4, y4 = map(int, input().split())

if ccw(x1, y1, x2, y2, x3, y3) * ccw(x1, y1, x2, y2, x4, y4) < 0 and \

   ccw(x3, y3, g, h, x1, y1)*ccw(x3, y3, g, h, x2, y2)<0:

    print(1)

else:

    print(0)

BJ_17387 선분 교차 2 (Gold III) 

def ccw(x1, y1, x2, y2, x3, y3):

    total = (x2-x1) * (y3-y1) - (y2-y1) * (x3-x1)

    return (total > 0) - (total < 0)

x1, y1, x2, y2 = map(int, input().split())

x3, y3, x4, y4 = map(int, input().split())

D1, D2 = ccw(x1, y1, x2, y2, x3, y3), ccw(x1, y1, x2, y2, x4, y4)

D3, D4 = ccw(x3, y3, x4, y4, x1, y1), ccw(x3, y3, x4, y4, x2, y2)

if D1 == D2 == 0:

    lo, hi = min((x1, y1), (x2, y2)), max((x1, y1), (x2, y2))

    if lo <= min((x3, y3), (x4, y4)) <= hi:

        print(1)

    else:

        print(0)

elif D1 * D2 <= 0 and D3 * D4 <= 0:

    print(1)

else:

    print(0)

BJ_1708 볼록 껍질 (Gold I) 

def ccw(p1, p2, p3):

    v, u = (p2[0] - p1[0], p2[1] - p1[1]), (p3[0] - p2[0], p3[1] - p2[1])

    if v[0] * u[1] > v[1] * u[0]:

        return True

    return False

def convex_hull(points):

    convex = []

    for p3 in points:

        while len(convex) >= 2:

            p1, p2 = convex[-2], convex[-1]

            if ccw(p1, p2, p3):

                break

            convex.pop()

        convex.append(p3)

    return len(convex)

n, answer = int(input()), -2

points = list(sorted(tuple(map(int, input().split())) for _ in range(n)))

answer += convex_hull(points)

points.reverse()

answer += convex_hull(points)

print(answer)

KT_zanzibar (1.5)     

n_test = int(input())

for i in range(n_test):

    li = list(map(int, input().split()))

    ret = 0

    for i in range(1, len(li) - 1):

        ret += max(0, li[i] - li[i - 1] * 2)

    print(ret)

        

a, b, c, d = map(int, input().split())

s = sum([a, b, c, d]) / 2

print(((s - a) * (s - b) * (s - c) * (s - d)) ** 0.5)

KT_beavergnaw (1.4) 

import math

while True:

    a, b = map(int, input().split())

    if a == b == 0:

        break

    print((a * a * a - 6 * b / math.pi) ** (1/3))

prime | gcd, lcm

유클리드 호제법 

Prime numbers

Prime factorization exercise

Q. 36 =

BJ_2501 약수 구하기 (Bronze III) 

p, q = map(int, input().split())

for i in range(1, p + 1):

    if p % i == 0:

        q -= 1

    if q == 0:

        print(i)

        break

else:

    print(0)

BJ_10610 30 (Silver V) 

li = list(map(int, input()))

if sum(li) % 3 != 0 or 0 not in li:

    print(-1)

else:

    print(*sorted(li, reverse=True), sep='')

BJ_1037 약수 (Silver V)

N = int(input())

li = sorted(map(int, input().split()))

print(li[0] * li[-1])

BJ_11653 소인수분해 (Silver IV)

n = int(input())

for i in range(2, n + 1):

    while n % i == 0:

        n //= i

        print(i) 

BJ_1978 소수 찾기 (Silver IV)

def is_prime(n):

    if n < 2:

        return False

    for i in range(2, int(n ** 0.5) + 1):

        if n % i == 0:

            return False

    return True

N = int(input())

arr = list(map(int, input().split()))

ret = 0

for n in arr:

    if is_prime(n):

        ret += 1

print(ret)

BJ_11502 세 개의 소수 문제 (Silver III) 

from itertools import combinations_with_replacement

is_prime = [False, False] + [True] * (1000)

primes = []

for i in range(2, len(is_prime)):

    if is_prime[i]:

        primes.append(i)

        for j in range(2 * i, len(is_prime), i):

            is_prime[j] = False

for _ in range(int(input())):

    n = int(input())

    for a, b, c in combinations_with_replacement(primes, 3):

        if a + b + c == n:

            print(a, b, c)

            break

    else:

        print(0)

BJ_1929 소수 구하기 (Silver II) 

N = int(input())

li = list(map(int, input().split()))

ret = 0

for n in li:

    if is_prime(n):

        ret += 1

print(ret)

BJ_4948 베르트랑 공준 (Silver II) 

is_prime = [False, False, True] + [True] * (123456 * 2)

for i in range(2, len(is_prime)):

    if is_prime[i]:

        for j in range(2 * i, len(is_prime), i):

            is_prime[j] = False

           

while True:

    N = int(input())

    if N == 0:

        break

       

    count = 0

    for n in range(N + 1, N * 2 + 1):

        if is_prime[n]:

            count += 1

    print(count)

BJ_15965 K번째 소수 (Silver II)

is_prime = [False, False, True] + [True] * (7368788)

count = int(input())

for i in range(2, len(is_prime)):

    if is_prime[i]:

        count -= 1

        if count == 0:

            print(i)

        for j in range(2 * i, len(is_prime), i):

            is_prime[j] = False

BJ_9020 골드바흐의 추측 (Silver I) 

is_prime = [False, False, True] + [True] * (123456 * 2)

for i in range(2, len(is_prime)):

    if is_prime[i]:

        for j in range(2 * i, len(is_prime), i):

            is_prime[j] = False

n = int(input())

for k in range(n):

    n = int(input())

    for i in range(n//2, n + 1):

        if is_prime[i] and is_prime[n - i]:

            print(f'{is_prime[n - i]} {is_prime[i]}')

            break

BJ_2581 소수 (Silver I) 

M, N = int(input()), int(input())

li = []

for n in range(M, N + 1):

    if is_prime(n):

        li.append(n)

       

if len(li) == 0:

    print(-1)

else:

    print(sum(li))

    print(min(li))

BJ_1016 제곱 ㄴㄴ 수 (Gold I)

mn, mx = map(int, input().split())

li = [1] * (mx - mn + 1)

for root in range(2, int(mx ** 0.5) + 1):

    square = root ** 2

    for n in range(max(mn // square, 1), mx // square + 1):

        if mn <= square * n <= mx:

            li[square * n - mn] = 0

   

print(sum(li))

Greatest common factor exercise 

Least common multiple exercise

Least common multiple exercise 2 

Least common multiple exercise 3 

# 50 26 GCD

85ME_Prime | LCM | GCD(edit)

85ME_Prime | LCM | GCD

is 2 prime?

        11이 소수인가?

        111이 소수인가?

        12 36 GCD

15 48 LCM

9 17 GCD

108 18 LCM

24 111 GCD

13 93 LCM

36 88 GCD

BJ_5618 공약수 (Bronze III) 

def GCD(x, y):  

    while(y):

        x, y = y, x % y

    return x

 

input()

s = list(map(int, input().split()))

g = GCD(s[0], GCD(s[1], s[-1]))

for i in range(1, (g // 2) + 1):

    if g % i == 0:

        print(i)

print(g)

BJ_2702 초6 수학 (Bronze I)

def GCD(x, y):  

   while y :

       x, y = y, x % y

   return x

def LCM(a, b):

    return a * b // GCD(a, b)

for _ in range(int(input())):

    a, b = map(int, input().split())

    print(LCM(a, b), GCD(a, b))

BJ_9506 약수들의 합 (Bronze I)

def divisors(num):

    li = [1]

    for i in range(2, int(num ** 0.5 + 1)):

        if num % i == 0:

            li.append(i)

            if i != num // i:

                li.append(num // i)

    return sorted(li)

while True:

    n = int(input())

    if n == -1:

        break

    divs_n = divisors(n)

    if sum(divs_n) == n:

        print(n, '=', ' + '.join(map(str, divs_n)))

    else:

        print(f"{n} is NOT perfect.")  

BJ_2609 LCM, GCD (Silver V) 

def GCD(a, b):  

   while(b):

       a, b = b, a % b

   return a

def LCM(a, b):

    return a * b // GCD(a, b)

a, b = map(int, input().split())

print(GCD(a, b), LCM(a, b))

BJ_1934 최소공배수 (Silver V)

BJ_5347 LCM (Silver IV) 

def GCD(a, b):  

    while(b):

        a, b = b, a % b

    return a

def LCM(a, b):

    return a * b // GCD(a, b)

for _ in range(int(input())):

    a, b = map(int, input().split())

    print(LCM(a, b))

BJ_13241 최소공배수 (Silver III) 

def GCD(a, b):  

    while(b):

        a, b = b, a % b

    return a

def LCM(a, b):

    return a * b // GCD(a, b)

a, b = map(int, input().split())

print(LCM(a, b))

BJ_9613 GCD 합 (Silver III) 

from itertools import combinations

def GCD(a, b):  

    while(b):

        a, b = b, a % b

    return a

n = int(input())

for _ in range(n):

    li = list(map(int, input().split()))

    print(sum(GCD(a, b) for a, b in combinations(li[1:], 2)))

! Series

BJ_8393 합 (Bronze V)

n = int(input())

print(n * (n + 1) // 2)

BJ_2355 시그마 (Bronze III)

a,b = map(int,input().split())

print((a + b) * (abs(a - b) + 1) // 2)

BJ_16561 3의 배수 (Bronze III)

n = int(input())

res = n // 3 - 1

print(res * (res - 1) // 2)

BJ_1964 오각형 (Bronze III)

n = int(input())

print((n + 1) * (n * 3 + 2) // 2 % 45678)

BJ_1789 수들의 합 (Silver V) 

s = int(input())

n = 1

while n * (n + 1) / 2 <= s:

    n += 1

print(n - 1)

KT_chanukah (1.3)

n_test = int(input())

for i in range(n_test):

    t, n = map(int, input().split())

    print(t, n + (n * (n + 1)) // 2)

[11] Greedy

AB_3 Greedy Method

Two Pointer

BJ_2003 수들의 합 2 (Silver III) 

N, M = map(int, input().split())

nums = list(map(int, input().split()))

accums = [0] * (N + 1)

for i in range(1, N + 1):

    accums[i] = accums[i - 1] + nums[i - 1]  

count = 0

for l in range(N):

    for r in range(l + 1, N + 1):

        if accums[r] - accums[l] > M:

            break

        elif accums[r] - accums[l] == M:

            count += 1

            break

print(count)

BJ_1946 신입 사원 (Silver I) 

import sys

input = sys.stdin.readline

for _ in range(int(input())):

    n = int(input())

    score = sorted([tuple(map(int, input().split())) for _ in range(n)])

    p, ans = n+1, 0

    for s, e in score:

        if p > e:

            ans += 1

            p = e

    print(ans)

BJ_1644 소수의 연속합 (Gold III) 

is_prime = [True for _ in range(4000001)]

for i in range(2, int(len(is_prime) ** 0.5)):

    if is_prime[i]:

        for j in range(i+i, len(is_prime), i):

            is_prime[j] = False

primes = [i for i, j in enumerate(is_prime) if j == True and i >=2 ]

sum_prime = [0] * (len(primes) + 1)

for i in range(len(primes)):

    sum_prime[i+1] = sum_prime[i] + primes[i]

N = int(input())

answer = 0

l, r = 0, 1

while l < len(primes):

    if sum_prime[r] - sum_prime[l] == N:

        answer += 1

        l += 1

    elif sum_prime[r] - sum_prime[l] < N and r < len(primes) - 1:

        r += 1

    else:

        l += 1

print(answer)

LC_15 3sum (medium) 

class Solution:

    def threeSum(self, nums: List[int]) -> List[List[int]]:

        res = []

        nums.sort()

        for i in range(len(nums) - 2):

            if i > 0 and nums[i] == nums[i-1]:

                continue

            l, r = i + 1, len(nums)-1

            while l < r:

                s = nums[i] + nums[l] + nums[r]

                if s < 0:

                    l += 1

                elif s > 0:

                    r -= 1

                else:

                    res.append((nums[i], nums[l], nums[r]))

                    while l < r and nums[l] == nums[l+1]:

                        l += 1

                    while l < r and nums[r] == nums[r-1]:

                        r -= 1

                    l += 1; r -= 1

        return res

Optimize | others

BJ_2839 설탕 배달 (Bronze I) 

# Greedy

N = int(input())

for i in range(0, N + 1, 3):

    if (N - i) % 5 == 0:

        print(i // 3 + (N - i) // 5)

        break

else:

    print(-1)

BJ_14916 거스름돈 (Silver V) 

N = int(input())

for i in range(0, N + 1, 2):

    if (N - i) % 5 == 0:

        print(i // 2 + (N - i) // 5)

        break

else:

    print(-1)

BJ_2217 로프 (Silver IV)

N = int(input())

li = list(sorted([int(input()) for _ in range(N)], reverse=True))

ret = 0

for i, n in enumerate(li):

    if (i + 1) * n > ret:

        ret = (i + 1) *n        

print(ret)

BJ_1931 회의실배정 (Silver II) 

import sys

input = sys.stdin.readline

N = int(input())

discuss = [list(map(int, input().split())) for _ in range(N)]

cnt, time_now = 0, -1

for diss in sorted(discuss, key=lambda x: (x[1], x[0])):

    if diss[0]>=time_now: #회의 시작 시간 >= 현재 시간

        time_now = diss[1]

        cnt+=1

       

print(cnt)

BJ_11047 동전 O (Silver I)

N, K = map(int, input().split())

li = [int(input()) for _ in range(N)]

ret = 0

for n in reversed(li):

    ret += K // n

    K %= n

print(ret)

BJ_13904 과제 (Gold III)

N=int(input())

L = []

for i in range(N):

    due, score = map(int,input().split())

    L.append((score, due))

L.sort(reverse=True)

busy, total = set(), 0

for i in range(N):

    score, due = L[i]

    for j in range(due, 0, -1):

        if j not in busy:

            busy.add(j)

            total += score

            break

print(total)

BJ_14659 한조서열정리하고옴 (Bronze II) 

N = int(input())

li = list(map(int, input().split()))

cur_height, cnt, mx = 0, 0, 0

for h in li:

    if cur_height < h:

        cur_height = h

        cnt = 0

    else:

        cnt += 1

    mx = max(cnt, mx)

print(mx)

BJ_1783 병든 나이트 (Silver V) 

n, m = map(int, input().split())

if n == 1:

    print(1)

elif n == 2:

    print(min(4, (m + 1) // 2))

elif m <= 6:

    print(min(4, m))

else:

    print(m - 2)

BJ_13305 주유소 (Silver IV) 

n=int(input())

a=[int(i) for i in input().split()]

b=[int(i) for i in input().split()]

c, r = 0, 0

for i in range(n-1):

    if b[i]<b[c]:

        c=i

    r+=a[i]*b[c]

print(r)

BJ_1439 뒤집기 (Silver V) 

S = input()

count = 0

for i in range(len(S)-1):

    if S[i] != S[i+1]:

        count += 1

print((count + 1) // 2)

BJ_1138 한 줄로 서기 (Silver II) 

n = int(input())

a = list(map(int, input().split()) )

b = []

for i in range(n):

    b.insert(a[n-1-i], n - i)

print(*b)

BJ_1541 잃어버린 괄호 (Silver II) 

equations = input().split('-')

ret = 0

for i, equation in enumerate(equations):

    for num in equation.split('+'):

        ret += int(num) if i == 0 else -int(num)

print(ret)

BJ_2138 전구와 스위치 (Silver II)

def change(A, B):

    press = 0

    for i in range(1, n):

        if A[i-1] == B[i-1]:

            continue

        press += 1

        for j in range(i-1, i+2):

            if j < n:

                A[j] ^= 1

               

    return press if A == B else float('inf')

n = int(input())

A = list(map(int,input()))

B = list(map(int,input()))

f_A = A[:]

f_A[0] ^= 1

f_A[1] ^= 1

res = min(change(A, B), 1 + change(f_A, B))

print(res if res != float('inf') else -1)

BJ_1080 행렬 (Silver II) 

N, M =map(int,input().split())

A = [list(map(int,list(input()))) for _ in range(N)]

B = [list(map(int,list(input()))) for _ in range(N)]

def flip(G, x,y):

    for i in range(x,x+3):

        for j in range(y,y+3):

            G[i][j] = 1 - G[i][j]

cnt = 0

for i in range(0,N-2):

    for j in range(0,M-2):

        if A[i][j] !=B[i][j]:

            flip(A, i,j)

            cnt+=1

for i in range(N):

    for j in range(M):

        if A[i][j] != B[i][j]:

            print(-1)

            exit()

print(cnt)

BJ_11509 풍선 맞추기 (Silver I) 

from collections import Counter

input()

count = 0

height_cnt = Counter()

for h in map(int,input().split()):

    if height_cnt[h] != 0:

        height_cnt[h] -= 1

        height_cnt[h - 1] += 1

    else:

        height_cnt[h - 1] += 1

print(sum(height_cnt.values()))

BJ_1339 단어 수학 (Gold IV)

t = int(input())

ss = [input() for _ in range(t)]

alphabet = [0 for i in range(26)]

for s in ss:

    i = 0

    while s:

        now = s[-1]

        alphabet[ord(now) - ord('A')] += 10 ** i

        i += 1

        s = s[:-1]

alphabet.sort(reverse=True)

ans = 0

for i in range(9, 0, -1):

    ans += i * alphabet[9 - i]

print(ans)

sweeping | bruteforce

BJ_2594 놀이공원 (Silver III) 

times = [(0, 600), (1320, 1440)]

for _ in range(int(input())):

    a, b = input().split()

    times.append((int(a[:2]) * 60 + int(a[2:]) - 10, int(b[:2]) * 60 + int(b[2:]) + 10))

times.sort()

mx, last_ended = 0, 600

for start, end in times:

    mx = max(mx, start - last_ended)

    last_ended = max(last_ended, end)

   

print(mx)

BJ_14790 Tidy Numbers (Bronze III)

BJ_14791 Tidy Numbers (Silver III) 

def preceding_tidy(number):

    number = list(map(int, number))

    for i in range(len(number)-2, -1, -1):

        if number[i] > number[i+1]:

            number[i] -= 1

            for j in range(i+1, len(number)):

                number[j] = 9

    return ''.join(str(n) for n in number).lstrip('0')

 

for i in range(int(input())):

    print(f"Case #{i + 1}: {preceding_tidy(input())}")

BJ_18111 마인크래프트 (Silver III) 

import sys

input = sys.stdin.readline

n, m, b = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(n)]

height, ans = 0, float('inf')

for i in range(257):

    mx, mn = 0, 0

    for row in G:

        for e in row:

            if e < i:

                mn += i - e

            else:

                mx += e - i

    if mx + b >= mn:

        time = 2 * mx + mn

        if time <= ans:

            ans = time

            height = i

print(ans, height)

BJ_1107 리모컨 (Gold V)

working_buttons = {str(x) for x in range(11)}

N = int(input())

n_broken = int(input())

if n_broken != 0:

    working_buttons -= set(input().split())

   

result = abs(N - 100)

for i in range(1000001):

    if len(set(str(i)) - working_buttons) == 0:

        result = min(result, abs(N - i) + len(str(i)))

print(result)

 

[12] DP

Game | optimization | Others

BJ_9655 돌 게임 (Silver IV) 

n = int(input())

print('CY' if n % 2 == 0 else 'SK')

BJ_9656 돌 게임 2 (Silver IV)

n = int(input())

print('CY' if n % 2 == 1 else 'SK')

BJ_9657 돌 게임 3 (Silver II) 

n = int(input())

dp = [False, True, False, True, True]

for i in range(n - 4):

    dp.append(not all([dp[-4], dp[-3], dp[-1]]))

print("SK" if dp[n] else "CY")

BJ_9658 돌 게임 4 (Silver I)

n = int(input())

dp = [True, False, True, False]

for i in range(n - 3):

    dp.append(not all([dp[-4], dp[-3], dp[-1]]))

print("SK" if dp[n] else "CY")

BJ_9659 돌 게임 5 (Gold V)

print('SK' if int(input()) % 2 else 'CY')

BJ_9660 돌 게임 6 (Gold V)

print("CY" if int(input()) % 7 in [0, 2] else "SK")

hBJ_9661 돌 게임 7 (Gold II)

print("CY" if int(input()) % 5 in [0, 2] else "SK")

BJ_14501 퇴사 (Silver IV) 

n = int(input())

t = []

p = []

dp = []

for i in range(n):

    a, b = map(int, input().split())

    t.append(a)

    p.append(b)

    dp.append(b)

dp.append(0)

for i in range(n - 1, -1, -1):

    if t[i] + i > n:

        dp[i] = dp[i + 1]

    else:

        dp[i] = max(dp[i + 1], p[i] + dp[i + t[i]])

print(dp[0])

BJ_2670 연속부분최대곱 (Silver IV) 

n = int(input())

li = [float(input()) for _ in range(n)]

dp = []

for n in li:

    if len(dp) and dp[-1] > 1:

        dp.append(dp[-1] * n)

    else:

        dp.append(n)

print(f"{max(dp):.3f}")

BJ_1912 연속합 (Silver II) 

input()

li = list(map(int,input().split()))

dp = []

for n in li:

    dp.append(dp[-1] + n if len(dp) and dp[-1] > 0 else n)

print(max(dp))

BJ_9251 LCS (Gold V) 

S1 = input()

S2 = input()

dp = [[0] * (len(S2) + 1) for _ in range(len(S1) + 1)]

for i, c1 in enumerate(S1):

    for j, c2 in enumerate(S2):

        if c1 == c2:

            dp[i + 1][j + 1] = dp[i][j] + 1

        else:

            dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j])

print(dp[-1][-1])

BJ_9252 LCS 2 (Gold V) 

S1 = input()

S2 = input()

dp = [[""] * (len(S2) + 1) for _ in range(len(S1) + 1)]

for i, c1 in enumerate(S1):

    for j, c2 in enumerate(S2):

        if c1 == c2:

            dp[i + 1][j + 1] = dp[i][j] + c1

        else:

            if len(dp[i][j + 1]) > len(dp[i + 1][j]):

                dp[i + 1][j + 1] = dp[i][j + 1]

            else:

                dp[i + 1][j + 1] = dp[i + 1][j]

print(len(dp[-1][-1]))

print(dp[-1][-1])

BJ_1958 LCS 3 (Gold III) 

A, B, C = input(), input(), input()

dp = [[[0] * (len(C) + 1) for j in range(len(B) + 1)] for k in range(len(A) + 1)]

for i, a in enumerate(A):

    for j, b in enumerate(B):

        for k, c in enumerate(C):

            if a == b == c:

                dp[i + 1][j + 1][k + 1] = dp[i][j][k] + 1

            else:

                dp[i + 1][j + 1][k + 1] = max(dp[i][j + 1][k + 1], dp[i + 1][j][k + 1], dp[i + 1][j + 1][k], \

                                              dp[i][j][k + 1], dp[i + 1][j][k], dp[i][j + 1][k])

               

print(dp[-1][-1][-1])

BJ_1806 부분합 (Gold III) 

N, s = map(int, input().split())

li = list(map(int, input().split()))

acc = [0]

for n in li:

    acc.append(acc[-1] + n)

   

mn_len = N

for i in range(N):

    lo, hi = i, N - 1

    if acc[hi + 1] - acc[i] < s:

        break

    while lo < hi:

        mi = (lo + hi) // 2

        if s <= acc[mi + 1] - acc[i]:

            hi = mi

        else:

            lo = mi + 1

    mn_len = min(mn_len, lo - i + 1)

print(0 if i == 0 else mn_len)

BJ_11054 가장 긴 바이토닉 부분 수열 (Gold III) 

N = int(input())

li = list(map(int, input().split()))

increase = [1 for _ in range(N)]

decrease = [1 for _ in range(N)]

mx_bitonic = 1

for i in range(N):

    for j in range(i):

        if li[i] > li[j]:

            increase[i] = max(increase[i], increase[j] + 1)

           

for i in range(N-1, -1, -1):

    for j in range(i + 1, N):

        if li[i] > li[j]:

            decrease[i] = max(decrease[i], decrease[j] + 1)

        mx_bitonic = max(mx_bitonic, decrease[i] + increase[i] - 1)

       

print(mx_bitonic)

BJ_11049 행렬 곱셈 순서 (Gold III) 

n = int(input())

s = [list(map(int, input().split())) for i in range(n)]

dp = [[0] * n for i in range(n)]

for i in range(1, n):

    for j in range(n - i):

        x = j + i

        dp[j][x] = 2 ** 32

        for k in range(j, x):

            dp[j][x] = min(dp[j][x], dp[j][k] + dp[k + 1][x] + s[j][0] * s[k][1] * s[x][1])

print(dp[0][-1])

BJ_2167 2차원 배열의 합 (Bronze II)

n, m = map(int, input().split())

dp = [[0] * (m + 1) for _ in range(n + 1)]

for i in range(n):

    w, v = map(int, input().split())

    for j in range(m + 1):

        dp[i + 1][j] = max(dp[i][j], 0 if w > j else dp[i][j - w] + v)

       

print(dp[-1][-1])

BJ_9461 파도반 수열 (Silver III) 

N = int(input())

dp = [0, 1, 1]

for i in range(2, 102):

    dp.append(dp[-1] + dp[-3])

   

for _ in range(N):

    a = int(input())

    print(dp[a])

dp = [0, 1]

for n in range(3, int(input()) + 1):

    dp.append((n - 1) * (dp[-1] + dp[-2]) % 1000000000)

print(dp[-1])

 

BJ_1947 선물 전달 (Gold III) 

n = int(input())

a, b = 1, 0

for i in range(2, n+1) :

    a, b = b, ((i-1)*(a + b)) % 10**9

print(b)

BJ_1126 같은 탑 (Platinum II) 

n = int(input())

li = list(map(int, input().split()))

dp = [[-1] * (500001) for _ in range(n + 1)]

dp[0][0] = 0

for i, h in enumerate(li):

    for d in range(500001):

        dp[i + 1][d] = dp[i][d]

        if d >= h and dp[i][d - h] != -1:

            dp[i + 1][d] = max(dp[i + 1][d], dp[i][d - h] + h)

        if h >= d and dp[i][h - d] != -1:

            dp[i + 1][d] = max(dp[i + 1][d], dp[i][h - d] + d)

        if d + h <= 500000 and dp[i][d + h] != -1:

            dp[i + 1][d] = max(dp[i + 1][d], dp[i][d + h])

       

print(-1 if dp[n][0] == 0 else dp[n][0])

LC_121 best-time-to-buy-and-sell-stock 

# row        # transaction

# col        day

vector<vector<int>> dp(k + 1, vector<int>(N));

for (int i = 1; i <= k; i++){

    int mx = -v[0];

    for (int j = 1; j < N; j++){

        dp[i][j] = max(dp[i][j - 1], mx + v[j]);

        mx = max(mx, dp[i - 1][j] - v[j]);

    }

}

return dp[k][N - 1];

LC_312 Burst-balloons                 # burst gives nums[left] * nums[i] * nums[right] point

def maxCoins(self, li):

    li = [1] + li + [1]

    n = len(li)

    dp = [[0] * n for _ in range(n)]        # dp[i][j] coins obtained from balloons between index i and j

    for gap in range(2, n):

        for i in range(n - gap):

            j = i + gap

            for k in range(i+1, j):                # k is last balloon index

                dp[i][j] = max(dp[i][j], li[i] * li[k] * li[j] + dp[i][k] + dp[k][j])

    return dp[0][n-1]

LC_10 regular-expression-matching 

bool isMatch(string s, string p) {

    int N = s.size(), M = p.size();

    vector<vector<bool>> dp(N + 1, vector<bool>(M + 1, false));

    dp[0][0] = true;

    for (int j = 0; j < M; j++) {

        if (p[j] == '*') {

            dp[0][j + 1] = dp[0][j - 1];

        }

    }

    for (int i = 0 ; i < N; i++) {

        for (int j = 0; j < M; j++) {

            if (p[j] == '.' || p[j] == s[i])

                dp[i + 1][j + 1] = dp[i][j];

            if (p[j] == '*') {

                if (p[j - 1] == s[i] || p[j - 1] == '.')

                    dp[i + 1][j + 1] = dp[i + 1][j] || dp[i][j + 1]

                                                    || dp[i + 1][j - 1];

                else

                    dp[i + 1][j + 1] = dp[i + 1][j - 1];

            }

        }

    }

    return dp[N][M];

}

Unique | Optimized path

BJ_9095 1, 2, 3 더하기 (Silver III) 

dp = [1, 1, 2]

for n in range(3, 11):

    dp.append(dp[n-1] + dp[n-2] + dp[n-3])

for i in range(int(input())):

    print(dp[int(input())])

BJ_12101 1, 2, 3 더하기 2 (Silver I) 

n, k = map(int, input().split())

cnt = 0

def dfs(cur, total, string):

    global cnt

    if cur > total:

        return

    if cur == total:

        cnt += 1

        if cnt == k:

            print(string[1:])

            exit(0)

    dfs(cur + 1, total, string + '+1')

    dfs(cur + 2, total, string + '+2')

    dfs(cur + 3, total, string + '+3')

   

dfs(0, n, '')

print(-1)

BJ_15988 1, 2, 3 더하기 3 (Silver II)

import sys

input = sys.stdin.readline

dp = [1, 1, 2]

for i in range(3, 1000001):

    dp.append((dp[i - 1] + dp[i - 2] + dp[i - 3]) % 1000000009)

for i in range(int(input())):

    n = int(input())

    print(dp[n])

dp = [1, 1, 2]

for n in range(3, 1000001):

    dp.append(dp[n-1] + dp[n-2] + dp[n-3])

for i in range(int(input())):

    print(dp[int(input())] % 1000000009)

BJ_15989 1, 2, 3 더하기 4 (Silver I) 

dp = [1 for i in range(10001)]

for i in range(2, 10001):

    dp[i] += dp[i - 2]

   

for i in range(3, 10001):

    dp[i] += dp[i - 3]

   

for _ in range(int(input())):

    print(dp[int(input())])

BJ_2293 동전 1 (Silver I) 

N, total = map(int, input().split())

li = [int(input()) for _ in range(N)]

dp = [0] * (total + 1)

dp[0] = 1

for i in range(N):

    coin = li[i]

    for value in range(coin, total + 1):

        dp[value] += dp[value - coin]

   

print(dp[-1])

BJ_11057 오르막 수 (Silver I) 

N = int(input())

dp = [1] * 10

for i in range(N - 1):

    for j in range(1, 10):

        dp[j] += dp[j - 1]

    print(dp)

print(sum(dp) % 10007)

BJ_2225 합분해 (Gold V) 

N, K = map(int, input().split())

mod = 1000000000

table = [1] + [0] * N

for _ in range(1, K+1):

    for i in range(1, N+1):

        table[i] = (table[i] + table[i-1]) % mod

print(str(table[N]))

LC62_ Unique-paths                         # unique paths from TL to BR

def uniquePaths(self, m, n):

    dp = [1] * n

    for i in range(1, m):

        for j in range(1, n):

            dp[j] = dp[j - 1] + dp[j]

    return dp[-1] if m and n else 0

Q. Given a target find minimum / maximum, cost / path / sum to reach the target

A. Choose min / max path among all possible paths before current state, then add value for current state

BJ_17626 Four Squares (Silver V) 

n = int(input())

dp = [0] + [float('inf')] * n

for n in range(n + 1):

    for root in range(int(n ** 0.5 + 1)):

        dp[n] = min(dp[n], dp[n - root ** 2] + 1)

print(dp[-1])

BJ_1699 제곱수의 합 (Silver III)

n = int(input())

dp = [0]*(n+1)

for i in range(1, n+1):

    dp[i] = i

    j = 1

    while j*j <= i:

        if dp[i] > dp[i-j*j]+1:

            dp[i] = dp[i-j*j]+1

        j += 1

print(dp[n])

BJ_11060 점프 점프 (Silver II) 

input()

li = list(map(int, input().split()))

dp = [0] + [1000] * (len(li) - 1)

for i in range(len(li)):

    for step in range(1, li[i] + 1):

        if i + step < len(dp):

            dp[i + step] = min(dp[i + step], dp[i] + 1)

       

print(dp[-1] if dp[-1] < 1000 else -1)

BJ_11048 이동하기 (Silver I) 

n, m = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(n)]

dp = [[0] * (m + 1) for i in range(n + 1)]

for i in range(1, n + 1):

    for j in range(1, m + 1):

        dp[i][j] = G[i - 1][j - 1] + max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])

print(dp[n][m])

LC_64 minimum-path-sum                

# find a path from top left to bottom right minimizes the sum

def minPathSum(self, grid):

    r, c = len(grid), len(grid[0])

    dp = [[0 for _ in range(c)] for _ in range(r)]

    dp[0][0] = grid[0][0]

    for i in range(1, r):

        dp[i][0] = dp[i-1][0] + grid[i][0]

    for i in range(1, c):

        dp[0][i] = dp[0][i-1] + grid[0][i]

    for i in range(1, r):

        for j in range(1, c):

            dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

    return dp[-1][-1]

LC221_ maximal-square                 

# largest square containing only 1's

def maximalSquare(self, G):

    if len(G) == 0:

        return 0

    n, m, ret, flag = len(G), len(G[0]), 0, 0

    dp = [[0] * (m + 1) for _ in range(n + 1)]

    for i in range(n):

        for j in range(m):

            if G[i][j] == '1':

                dp[i + 1][j + 1] = min(dp[i + 1][j], dp[i][j], dp[i][j + 1]) + 1

                ret = max(ret, dp[i + 1][j + 1])

       

    return ret ** 2

# with flag

    for i in range(n):

        for j in range(m):

            if G[i][j] == '1':

                dp[flag][j + 1] = min(dp[flag][j], dp[flag ^ 1][j], dp[flag ^ 1][j + 1]) + 1

                ret = max(ret, dp[flag][j + 1])

            else:

                dp[flag][j + 1] = 0

        flag ^= 1

kmp | Knapsack | TSP

BJ_1701 Cubeditor (Gold II) 

P = input()

def getPi(st):

    j = 0

    pi = [0] * len(st)

    for i in range(1, len(pi)):

        while j > 0 and st[i] != st[j]:

            j = pi[j-1]

        if st[i] == st[j]:

            j += 1

            pi[i] = j

    return max(pi)

res = 0

for i in range(len(P)):

    res = max(getPi(P[i:]), res)

print(res)

Knapsack problem w[1], ..., w[n] and values v[1], ..., v[n] given that you cannot have more weight than C.

        BJ_12865 평범한 배낭 (Gold V) 

n, m = map(int, input().split())

dp = [[0] * (m + 1) for _ in range(n + 1)]

for i in range(n):

    w, v = map(int, input().split())

    for j in range(m + 1):

        dp[i + 1][j] = max(dp[i][j], 0 if w > j else dp[i][j - w] + v)

       

print(dp[-1][-1])    

// row        current vertex

// col        visited bitset

const int N = 20, INF = 100000000;

int c[N][N];

int dp[N][1<<N];

memset(dp, -1, sizeof(dp));

int tsp(int i, int S) {

    if (S == ((1 << N) - 1))

        return c[i][0];

    if (dp[i][S] != -1)

        return dp[i][S];

    int res = INF;

    for (int j = 0; j < N; j++) {

        if (S & (1 << j))

            continue;

        res = min(res, c[i][j] + tsp(j, S | (1 << j)));

    }

    dp[i][S] = res;

    return res;

}

BJ_2098 외판원 순회 (Gold I)

INF=float('inf')

   

def find_path(last, visited, dp):

    if visited == (1<<N) - 1:

        return G[last][0] or INF

    if dp[last][visited] is not None:

        return dp[last][visited]

    tmp=INF

    for city in range(N):

        if visited & (1 << city) == 0 and G[last][city] != 0:

            tmp=min(tmp, find_path(city, visited | (1<<city), dp) + G[last][city])

    dp[last][visited]=tmp

    return tmp

N=int(input())

G=[list(map(int,input().split())) for _ in range(N]

dp = [[None]*(1<<N) for _ in range(N)]  # dp[a][b] = current node a, visited nodes bit

 

print(find_path(0, 1, dp))

 

Sparse Table

Brute Force                # Memory O(1)         Time O(N)

Dynamic Program        # Memory O(N^2)        Time O(1)

Segment Tree                # Memory O(N)        Time O(log N)

Sparse Table                # Memory O(NlogN)        Time O(1)

LCA                        # Memory O(N)        Time O(1)

BJ_17435 합성함수와 쿼리 (Gold I) 

import sys

input = sys.stdin.readline

m=int(input())

f=[0]+list(map(int, input().split()))

dp=[[f[i]] for i in range(m+1)]

for exp in range(19):   # log(20000) < 19

    for i in range(1,m+1):

        dp[i].append(dp[dp[i][exp]][exp])

for _ in range(int(input())):

    n, x = map(int, input().split())

    for exp in range(18, -1, -1):

        if n >= 2 ** exp:

            n -= 2 ** exp

            x = dp[x][exp]

    print(x)

BJ_11437 LCA (Gold III)

BJ_11438 LCA2 (Platinum V)  

import sys

from collections import deque

input = sys.stdin.readline

N=int(input())

T=[[] for _ in range(N+1)]

for _ in range(N-1):

    p,c = map(int,input().split())

    T[c].append(p)

    T[p].append(c)

   

node2parent=[0 for _ in range(N+1)]

node2depth= {1:0}

dq=deque([1])

while dq:

    p = dq.popleft()

    for c in T[p]:

        if c not in node2depth:

            node2parent[c] = p

            dq.append(c)

            node2depth[c] = node2depth[p] + 1

dp=[[0 for _ in range(17)] for i in range(N+1)]

for i in range(N+1):

    dp[i][0]=node2parent[i]

   

for j in range(1,17):

    for i in range(1,N+1):

        dp[i][j]=dp[dp[i][j-1]][j-1]

       

for _ in range(int(input())):

    a, b = map(int, input().split())

    if node2depth[a] > node2depth[b]:

        a, b = b, a

    dif = node2depth[b] - node2depth[a]

    for i in range(17):

        if dif & 1<<i:

            b=dp[b][i]

    if a == b:

        print(a)

        continue

    for i in range(16,-1,-1):

        if dp[a][i] != dp[b][i]:

            a=dp[a][i]

            b=dp[b][i]

    print(dp[b][0])

[13] Recursion | Backtrack

Recursion

Comparing Iterative and Recursive Factorial Functions 

Stepping Through Recursive Fibonacci Function

BJ_10870 피보나치 수 5 (Bronze II) 

def recur(n):

    if n <= 1:  return n

    return recur(n - 1) + recur(n - 2)

print(recur(int(input())))

BJ_17478 재귀함수가 뭔가요? (Silver V)

def recur(mx, cur):

    if cur == mx:

        print("____" * cur + '"재귀함수가 뭔가요?"')

        print("____" * cur + '"재귀함수는 자기 자신을 호출하는 함수라네"')

        print("____" * cur + '라고 답변하였지.')

        return

    print("____" * cur + '"재귀함수가 뭔가요?"')

    print("____" * cur + '"잘 들어보게. 옛날옛날 한 산 꼭대기에 이세상 모든 지식을 통달한 선인이 있었어.')

    print("____" * cur + '마을 사람들은 모두 그 선인에게 수많은 질문을 했고, 모두 지혜롭게 대답해 주었지.')

    print("____" * cur + '그의 답은 대부분 옳았다고 하네. 그런데 어느 날, 그 선인에게 한 선비가 찾아와서 물었어."')

    recur(mx, cur + 1)

    print("____" * cur + '라고 답변하였지.')

         

print("어느 한 컴퓨터공학과 학생이 유명한 교수님을 찾아가 물었다.")

n = int(input())

recur(n, 0)

BJ_2630 색종이 만들기 (Silver III)

def recur(r, c, n):

    global G, blue, white

    total = sum(sum(li[c : c + n]) for li in G[r : r + n])

    if total == 0:

        white +=1

    elif total == n ** 2:

        blue += 1

    else:

        recur(r, c, n // 2)

        recur(r + n // 2, c, n // 2)

        recur(r, c + n // 2, n // 2)

        recur(r + n // 2, c + n // 2, n // 2)

   

G = []

n = int(input())

for _ in range(n):

    G.append(list(map(int, input().split())))

   

blue = 0

white = 0

recur(0, 0, len(G))

print(white)

print(blue)

BJ_1780 종이의 개수 (Silver II) 

import sys

sys.setrecursionlimit(10**6)

input = sys.stdin.readline

def same(x, y, n):

    for i in range(x, x+n):

        for j in range(y, y+n):

            if G[x][y] != G[i][j]:

                return False

    return True

def solve(x, y, n):

    if same(x, y, n):

        cnt[G[x][y]+1] += 1

        return

    for i in range(0, 3):

        for j in range(0, 3):

            solve(x + i * n // 3, y + j * n // 3, n // 3)

cnt = [0] * 3

n = int(input())

G = [list(map(int, input().split())) for _ in range(n)]

solve(0, 0, n)

for i in cnt:

    print(i)

BJ_11729 하노이 탑 이동 순서 (Silver II) 

def hanoi(disk, start, mid, end):

    if disk == 1:

        moves.append([start, end])

    else:

        hanoi(disk - 1, start, end, mid)

        moves.append([start, end])

        hanoi(disk - 1, mid, start, end)

total_disk = int(input())

moves = []

hanoi(total_disk, 1, 2, 3)

print(len(moves))

for move in moves:

    print(move[0], move[1])

BJ_1074 Z (Silver I) 

def recur(N, r, c):

    if r == c == 0:

        return 0

    side = 2 ** (N - 1)

    return recur(N - 1, r % side, c % side) + side ** 2 * (r // side * 2 + c // side)

N, r, c = map(int, input().split())

print(recur(N, r, c))

BJ_2247 별 찍기 - 10 (Silver I) 

def recur(old_G):

    new_G=[]

    for i in range(3 * len(old_G)):

        if i // len(old_G) == 1:

            new_G.append(old_G[i % len(old_G)] + " " * len(old_G) + old_G[i % len(old_G)])

        else:

            new_G.append(old_G[i % len(old_G)] * 3)

    return new_G

G = ["*"]

i = 1

N = int(input())

while i != N:

    G = recur(G)

    i *= 3

   

for i in G:

    print(i)

BJ_1629 곱셈 (Silver I)

A, B, C = map(int, input().split())

def recur(A, B):

    if(B % 2 > 0):

        return recur(A, B - 1) * A

    elif(B == 0):

        return 1

    elif(B == 1):

        return A

    else:

        result = recur(A, B//2)

        return result ** 2 % C

print(recur(A, B) % C)

BJ_12100 2048 (Easy) (Gold II) 

from copy import deepcopy

def move(G, typ):

    result = []

    if typ == 0 or typ == 1:

        G = list(zip(*G))

    for idx in range(len(G)):

        row = G[idx]

        block = [i for i in row if i != 0]

        if typ == 0 or typ == 3:

            for i in range(1, len(block)):

                if block[i-1] ==  block[i]:

                    block[i-1] += block[i]

                    block[i] = 0

            block = [i for i in block if i != 0]

            block += [0] * (len(row) - len(block))

        else:

            for i in range(len(block) - 1, 0, -1):

                if block[i-1] == block[i]:

                    block[i] += block[i-1]

                    block[i-1] = 0

            block = [i for i in block if i != 0]

            block = [0] * (len(row) - len(block)) + block

        result.append(block)

    if typ == 0 or typ == 1:

        result = list(zip(*result))

    return result

   

def recur(G, count):

    if count == 0:

        return max([max(li) for li in G])

    return max([recur(move(deepcopy(G), typ), count - 1) for typ in range(4)])

n = int(input())

G = [list(map(int, input().split())) for _ in range(n)]

print(recur(G, 5))

Backtrack

Bounding function : kill some live nodes without actually expanding them

BJ_15649 N과 M (1) (Silver III) 

N, M = map(int, input().split())

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(1, N + 1):

        if i not in cur:

            cur.append(i)

            backtrack(cur, N, M)

            cur.pop()

backtrack([], N, M)

BJ_15650 N과 M (2) (Silver III) 

N, M = map(int, input().split())

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(cur[-1] + 1 if cur else 1, N + 1):

        cur.append(i)

        backtrack(cur, N, M)

        cur.pop()

backtrack([], N, M)

BJ_15651 N과 M (3) (Silver III) 

N, M = map(int, input().split())

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(1, N + 1):

        cur.append(i)

        backtrack(cur, N, M)

        cur.pop()

backtrack([], N, M)

BJ_15652 N과 M (4) (Silver III) 

N, M = map(int, input().split())

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(cur[-1] if cur else 1, N + 1):

        cur.append(i)

        backtrack(cur, N, M)

        cur.pop()

backtrack([], N, M)

BJ_15654 N과 M (5) (Silver III) 

N, M = map(int, input().split())

li=list(sorted(map(int, input().split())))

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(N):

        if not cur or li[i] != cur[-1]:

            cur.append(li[i])

            backtrack(cur, N, M)

            cur.pop()

backtrack([], N, M)

BJ_15654 N과 M (6) (Silver III) 

N, M = map(int, input().split())

li=list(sorted(map(int, input().split())))

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(N):

        if not cur or li[i] > cur[-1]:

            cur.append(li[i])

            backtrack(cur, N, M)

            cur.pop()

backtrack([], N, M)

BJ_15656 N과 M (7) (Silver III)

N, M = map(int, input().split())

li=list(sorted(map(int, input().split())))

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(N):

        cur.append(li[i])

        backtrack(cur, N, M)

        cur.pop()

backtrack([], N, M)

BJ_15657 N과 M (8) (Silver III) 

N, M = map(int, input().split())

li=list(sorted(map(int, input().split())))

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(N):

        if not cur or li[i] >= cur[-1]:

            cur.append(li[i])

            backtrack(cur, N, M)

            cur.pop()

backtrack([], N, M)

BJ_15663 N과 M (9) (Silver II) 

N, M = map(int, input().split())

li = list(sorted(map(int, input().split())))

def backtrack(cur, N, M):

    if len(cur) == M:

        print(*cur)

        return

    for i in range(N):

        if (not cur or cur[-1] != li[i]) and li[i] != li[i - 1]:

            cur.append(li[i])

            backtrack(cur, N, M)

            cur.pop()

backtrack([], N, M)

BJ_2529 부등호 (Silver II) 

def solve(ops, cur, results):

    idx = len(cur)

    if idx == len(ops) + 1:

        if len(results) <= 1:

            results.append(cur)

        results[-1] = cur

        return

    for i in range(10):

        if not c[i]:

            if idx == 0 or ops[idx - 1] == '<' and cur[-1] < str(i) or ops[idx - 1] == '>' and cur[-1] > str(i):

                c[i] = True

                solve(ops, cur + str(i), results)

                c[i] = False

               

n = int(input())

ops = input().split()

c = [False] * 10

results = []

solve(ops, "", results)

print(results[1], results[0], sep='\n')

BJ_9663  N-Queen (Gold V) 

N=int(input())

def backtrack(mx, c = 0, row=None, left=None, right=None):

    count = 0

    if c == 0:

        row, left, right = [0] * mx, [0] * 2 * mx, [0] * 2 * mx

    if c == mx:

        return 1

    for r in range(mx):

        if row[r] + left[c+r] + right[mx - 1 + c - r]==0:

            row[r] = left[c+r] = right[mx - 1 + c - r] = 1

            count += backtrack(mx, c + 1, row, left, right)

            row[r] = left[c + r] = right[mx - 1 + c - r] = 0

    return count

print(backtrack(N))

BJ_2580 스도쿠 (Gold IV) 

"""

Instance : a partially filled in puzzle.

Solution format : a grid with all squares filled with the numbers 1 through 9.

Constraint : There can be no repeats of numbers in each sub-square, row or column.

Objective : Find a solution with the constraint.

Fill the first available cell with the least possible number and recurse until any cell can't be filled in.

Go back to the last decision point and try the next biggest possible number.

"""

def backtrack(G):

    for r in range(9):

        for c, v in enumerate(G[r]):

            if v != 0:    continue

            box = [G[r//3*3+i][c//3*3+j] for i in range(3) for j in range(3)]

            row_col = G[r] + [G[i][c] for i in range(9)]

            for n in set(range(1, 10)) - set(box + row_col):

                G[r][c] = n

                if backtrack(G):

                    break

                else:

                    G[r][c] = 0

            else:

                return False                    

    return True

   

G = [list(map(int, input().split())) for _ in range(9)]

backtrack(G)

for l in G:

    for n in l:

        print(n, end = ' ')

    print()

https://www.acmicpc.net/problem/15655 

https://www.acmicpc.net/problem/15656 

https://www.acmicpc.net/problem/15657 

https://www.acmicpc.net/problem/15663 

LC_39 combination-sum 

# unique combinations in candidates where the candidate numbers sums to target

vector<vector<int>> combinationSum(vector<int> &v, int target) {

    vector<vector<int>> ret;

    sort(v.begin(), v.end());

    bt(v, 0, target, vector<int>(), ret);

    return ret;

}

void bt(vector<int>& v, int index, int target, vector<int> cur, vector<vector<int>>& ret) {

    if (target == 0) {

        ret.push_back(cur);

        return;

    }

    for (int i = index; i < v.size() && v[i] <= target; i++) {

        if (i == index || v[i] != v[i - 1]) {

            cur.push_back(v[i]);

            bt(v, i + 1, target - v[i], cur, ret);

            cur.pop_back();

        }

    }

}

[14] Graph

                        # adjacency matrix

                        # dict of dict {'a': {'b': -1, 'c':  4}, 'b': {'c':  3}, ...}

DFS | DP

BFS & DFS

BJ_4963 섬의 개수 (Silver II)

import sys

sys.setrecursionlimit(1500)

def dfs(G, w, h):

    if 0 <= w < len(G) and 0 <= h < len(G[0]) and G[w][h] == 1:

        G[w][h] = -1

        for i, j in [(1, 1), (1, 0), (1, -1), (0, 1), (0, -1), (-1, 0), (-1, 1), (-1, 0), (-1, -1)]:

            dfs(G, w + i, h + j)

   

while True:

    first_line = input()

    if first_line == "0 0":

        break

    w, h = map(int, first_line.split())

    G = []

    for i in range(h):

        G.append(list(map(int, input().split())))

       

    count = 0

    for r in range(h):    

        for c in range(w):

            if G[r][c] == 1:

                count += 1

                dfs(G, r, c)

    print(count)

 

BJ_11724 연결 요소의 개수 (Silver II) 

import sys

sys.setrecursionlimit(10000)

def dfs(G, start, visited=None):

    visited.add(start)

    for adj in G[start]:

        if adj not in visited:

            dfs(G, adj, visited)

N, M = map(int, input().split())

G = [[] for _ in range(N + 1)]

count = 0

for _ in range(M):

    u, v = map(int, input().split())

    G[u].append(v)

    G[v].append(u)

visited = set()

for j in range(1, N + 1):

    if j not in visited:

        dfs(G, j, visited)

        count += 1

print(count)

BJ_9466 텀 프로잭트 (Gold IV) 

for _ in range(int(input())):

    n = int(input())

    choice = list(n - 1 for n in map(int, input().split()))

    visit = [0] * n

    group = 1

    for i in range(n):

        while visit[i] == 0:

            visit[i] = group

            i = choice[i]

        while visit[i] == group:

            visit[i] = -1

            i = choice[i]

        group += 1

    print(n - visit.count(-1))

weakvertices 

from collections import defaultdict

while True:

    N = int(input())

    if N == -1:

        break

    G = defaultdict(set)

    for i in range(N):

        for j, e in enumerate(list(map(int, input().split()))):

            if e == 1:

                G[i].add(j)

    for i in range(N):

        count = 0

        for j in G[i]:

            count += sum([1 for k in G[j] if k in G[i]])

        if count == 0:

            print(i, end = ' ')

    print()

BJ_1520 내리막 길 (Gold IV) 

import sys

sys.setrecursionlimit(1500)

def dfs(G, r, c, dp):

    if dp[r][c] != -1:

        return dp[r][c]

    dp[r][c] = 0

    for nr, nc in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:

        if 0 <= nr < len(G) and 0 <= nc < len(G[0]):

            if G[nr][nc] < G[r][c]:

                dp[r][c] += dfs(G, nr, nc, dp)

    return dp[r][c]

m, n = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(m)]

dp = [[-1]*n for _ in range(m)]

dp[-1][-1] = 1

print(dfs(G, 0, 0, dp))

BFS | floodfill | DP

BJ_9372 상근이의 여행 (Silver III)

import sys

input = sys.stdin.readline

T = int(input())

for _ in range(T):

    N, M = map(int, input().split())

    for _ in range(M):

        a, b = map(int, input().split())

    print(N - 1)

BJ_2606 바이러스 (Silver III) 

from collections import deque

def bfs(G, start):

    dq, visited = deque([start]), set()

    while len(dq) != 0:

        v = dq.popleft()

        if v not in visited:

            visited.add(v)

            dq.extend(sorted(set(G[v]) - visited))

    return len(visited)

N, M = int(input()), int(input())

G = [[] for _ in range(N)]

for _ in range(M):

    u, v = map(int, input().split())

    G[u - 1].append(v - 1)

    G[v - 1].append(u - 1)

print(bfs(G, 0) - 1)

 

BJ_1260 DFS와 BFS (Silver II) 

from collections import deque

def dfs(G, v, visited=None):

    visited = visited or set([v])

    print(v, end=' ')

    for neighbor in sorted(G[v]):

        if neighbor not in visited:

            visited.add(neighbor)

            dfs(G, neighbor, visited)

    return visited

def bfs(G, start):

    dq, visited = deque([start]), set()

    while len(dq) != 0:

        v = dq.popleft()

        if v not in visited:

            print(v, end=' ')

            visited.add(v)

            dq.extend(sorted(set(G[v]) - visited))

N, M, v = map(int, input().split())

G = [[] for i in range(N+1)]

for i in range(M):

    a, b = map(int, input().split())

    G[a].append(b)

    G[b].append(a)

        

dfs(G, v)

print()

bfs(G, v)

BJ_5567 결혼식 (Silver I) 

from collections import deque

def bfs(G, start):

    dq, visited = deque([start]), set([start])

    for _ in range(2):

        for _ in range(len(dq)):

            v = dq.popleft()

            for e in G[v]:

                if e not in visited:

                    dq.append(e)

                    visited.add(e)

    return len(visited) - 1

V, E = int(input()), int(input())

G = [[] for _ in range(V + 1)]

for _ in range(E):

    u, v = map(int, input().split())

    G[u].append(v)

    G[v].append(u)

   

print(bfs(G, 1))

BJ_7576 토마토 (Silver I) 

from itertools import chain

from collections import deque

def bfs(G, rottens):

    dq = deque(rottens)

    while dq:

        for _ in range(len(dq)):

            r, c = dq.popleft()

            for nr, nc in [(r + 1, c),(r, c + 1),(r - 1, c),(r, c - 1)]:

                if 0 <= nr < len(G) and 0 <= nc < len(G[0]) and G[nr][nc] == 0:

                    G[nr][nc] = G[r][c] + 1

                    dq.append([nr, nc])

    return -1 if 0 in chain(*G) else max(chain(*G)) - 1

M, N = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(N)]

rottens = []

for i in range(N):

    for j in range(M):

        if G[i][j] == 1:

            rottens.append((i, j))

           

print(bfs(G, rottens))

BJ_2178 미로 탐색 (Silver I) 

import collections

def bfs(G, r, c):

    q = collections.deque([(r, c)])

    while q:

        r, c = q.popleft()

        for nr, nc in [(r,c-1),(r,c+1),(r-1,c),(r+1,c)]:

            if 0 <= nr < len(G) and 0 <= nc < len(G[0]) and G[nr][nc] == 1:

                q.append((nr, nc))

                G[nr][nc] = G[r][c] + 1

    return G[-1][-1]

N, M = map(int,input().split())

G = [list(map(int,input())) for _ in range(N)]

print(bfs(G, 0,0))

BJ_1697 숨바꼭질 (Silver I) 

from collections import deque

def bfs(start, end):

    dq, node2dist = deque([start]), {start : 0}

    while len(dq) != 0:

        v = dq.popleft()

        if v == end:

            return node2dist[end]

        for adj in [v + 1, v - 1, v * 2]:

            if adj not in node2dist and adj <= 100000:

                node2dist[adj] = node2dist[v] + 1

                dq.append(adj)

start, end = map(int, input().split())

print(bfs(start, end))

from collections import deque

from copy import deepcopy

def floodfill(G, r, c, colors):

    dq, visited = deque([(r, c)]), set([(r, c)])

    G[r][c] = '_'

    while len(dq) != 0:

        r, c = dq.popleft()

        for nr, nc in ([r, c + 1], [r, c - 1], [r + 1, c], [r - 1, c]):

            if 0 <= nr < len(G) and 0 <= nc < len(G[0]) and G[nr][nc] in colors:

                G[nr][nc] = '_'

                visited.add((nr, nc))

                dq.append((nr, nc))

    return len(visited)

BJ_2636 치즈 (Gold V) 

from copy import deepcopy

import collections

def bfs(G):

    dq, air = collections.deque([(0, 0)]), set([(0, 0)])

    while dq:

        r, c = dq.popleft()

        for nr, nc in [(r,c-1),(r,c+1),(r-1,c),(r+1,c)]:

            if 0 <= nr < len(G) and 0 <= nc < len(G[0]) and G[nr][nc] == 0 and (nr, nc) not in air:

                dq.append((nr, nc))

                air.add((nr, nc))

    return air

N, M = map(int, input().split())

G = [[0] * (M + 2)] + [[0] + list(map(int, input().split())) + [0] for _ in range(N)] + [[0] * (M + 2)]

cheeses = set([(r, c) for r in range(N + 2) for c in range(M + 2) if G[r][c] == 1])

count = 0

while len(cheeses):

    count += 1

    n_cheese = len(cheeses)

    air = bfs(G)

   

    for r, c in deepcopy(cheeses):

        if {(r + 1, c), (r - 1, c), (r, c - 1), (r, c + 1)} & air:

            G[r][c] = 0

            cheeses.remove((r, c))

       

print(count)

print(n_cheese)

       

BJ_10026 적록색약 (Gold V) 

N = int(input())

G = [list(input()) for _ in range(N)]

cb_G = deepcopy(G)

count = 0

for r in range(N):

    for c in range(N):

        if G[r][c] != '_':

            floodfill(G, r, c, G[r][c])

            count += 1

print(count, end=' ')

cb_count = 0

for r in range(N):

    for c in range(N):

        if cb_G[r][c] != '_':

            floodfill(cb_G, r, c, 'RG' if cb_G[r][c] != 'B' else 'B')

            cb_count += 1

print(cb_count)

BJ_13549 숨바꼭질 3 (Gold V) 

from collections import deque

def bfs(start, end):

    dq, node2dist = deque([start]), {start:0}

    while dq:

        v = dq.popleft()

        if v == end:

            return node2dist[v]

        for adj in (v - 1, v + 1, 2 * v):

            if adj not in node2dist and adj <= 100000:

                if adj == 2 * v:

                    node2dist[adj] = node2dist[v]

                    dq.appendleft(adj)

                else:

                    node2dist[adj] = node2dist[v] + 1

                    dq.append(adj)

   

start, end = map(int, input().split())

print(bfs(start, end))

BJ_13913 숨바꼭질 4 (Gold IV) 

from collections import deque

def bfs(start, end):

    dq, node2dist, node2head = deque([start]), {start : 0}, {}

    while len(dq) != 0:

        v = dq.popleft()

        for adj in [v + 1, v - 1, v * 2]:

            if adj not in node2dist and adj <= 100000:

                node2head[adj] = v

                node2dist[adj] = node2dist[v] + 0 if adj == v * 2 else 1

                dq.append(adj)

        if v == end:

            return node2head

start, end = map(int, input().split())

path = [end]

cur = end

node2head = bfs(start, end)

while cur != start:

    cur = node2head[cur]

    path.append(cur)

print(len(path) - 1)

print(*reversed(path))

BJ_14502 연구소 (Gold V) 

import copy

from collections import deque

from itertools import combinations, chain

def bfs(G, r, c):

    dq = deque()

    for r in range(len(G)):

        for c in range(len(G[0])):

            if G[r][c] == 2:

                dq.append((r, c))

    while dq:

        r, c = dq.popleft()

        for nr, nc in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:

            if 0 <= nr < n and 0 <= nc < m:

                if G[nr][nc] == 0:

                    G[nr][nc] = 2

                    dq.append((nr, nc))

    return list(chain(*G)).count(0)

n, m = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(n)]

blanks = []

for r in range(n):

    for c in range(m):

        if G[r][c] == 0:

            blanks.append((r, c))

           

ret = 0

for walls in combinations(blanks, 3):

    new_G = copy.deepcopy(G)

    for r, c in walls:

        new_G[r][c] = 1

    ret = max(ret, bfs(new_G, r, c))

print(ret)

BJ_17141 연구소 2 (Gold V) 

from copy import deepcopy

from collections import deque

from itertools import combinations

def bfs(G, virs):

    visited, dq = set(virs), deque([(*vir, 0) for vir in virs])

    last_change = 0

    while dq:

        r, c, cnt = dq.popleft()

        G[r][c] = 1

        for nr, nc in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:

            if 0 <= nr < len(G) and 0 <= nc < len(G) and (nr, nc) not in visited and G[nr][nc] != 1:

                visited.add((nr, nc))

                last_change = cnt + 1

                dq.append((nr, nc, cnt + 1))

    return last_change if sum([li.count(1) for li in G]) == len(G) ** 2 else float('inf')

n, m = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(n)]

virs = [(r, c) for r in range(n) for c in range(n) if G[r][c] == 2]

result = float('inf')

for selects in combinations(virs, m):

    result = min(result, bfs(deepcopy(G), selects))

print(-1 if result == float('inf') else result)

BJ_17142 연구소 3 (Gold IV) 

from copy import deepcopy

from collections import deque

from itertools import combinations

def bfs(G, virs):

    visited, dq = set(), deque([(*vir, 0) for vir in virs])

    last_change = 0

    while dq:

        r, c, cnt = dq.popleft()

        for nr, nc in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:

            if 0 <= nr < len(G) and 0 <= nc < len(G) and (nr, nc) not in visited and G[nr][nc] != 1:

                visited.add((nr, nc))

                if G[nr][nc] == 0:

                    G[nr][nc] = 2

                    last_change = cnt + 1

                dq.append((nr, nc, cnt + 1))

    return last_change if sum([li.count(0) for li in G]) == 0 else -1

BJ_1987 알파벳 (Gold IV) 

n, m = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(n)]

virs = [(r, c) for r in range(n) for c in range(n) if G[r][c] == 2]

result = float('inf')

for selects in combinations(virs, m):

    cur = bfs(deepcopy(G), selects)

    if cur != -1:

        result = min(result, cur)

print(-1 if result == float('inf') else result)

def BFS(G, x, y):

    answer = 1

    q = set([(x, y, G[x][y])])

    while q:

        x, y, ans = q.pop()

        for nr, nc in [(x + 1, y), (x, y + 1), (x - 1, y), (x, y - 1)]:

            if 0 <= nr < len(G) and 0 <= nc < len(G[0]) and G[nr][nc] not in ans:

                q.add((nr,nc,ans + G[nr][nc]))

                answer = max(answer, len(ans) + 1)

    return answer

R, C = map(int, input().split())

G = [input() for _ in range(R)]

return(BFS(G, 0, 0))

BJ_1939 중량제한 (Gold IV)

from collections import deque, defaultdict

def bfs(G, start, end, carry):

    dq = deque([start])

    visited = [i == start for i in range(len(G))]

    while dq:

        u = dq.popleft()

        for adj, limit in G[u].items():

            if not visited[adj] and carry <= limit:

                dq.append(adj)

                visited[adj] = True

    return visited[end]

   

n, m = map(int, input().split())

G = [defaultdict(int) for _ in range(n)]

for _ in range(m):

    u, v, w = map(int, input().split())

    G[u - 1][v - 1] = max(G[u - 1][v - 1], w)

    G[v - 1][u - 1] = max(G[v - 1][u - 1], w)

   

start, end = map(int, input().split())

start -= 1; end -= 1

lo_w = 1

hi_w = 1000000000

while lo_w < hi_w:

    mi_w = (hi_w + lo_w + 1) // 2

    if bfs(G, start, end, mi_w):

        lo_w = mi_w

    else:

        hi_w = mi_w - 1

       

print(lo_w)

BJ_1012 유기농 배추 (Silver II) 

from collections import deque

def floodfill(G, r, c):

    dq = deque([(r, c)])

    G[r][c] = 0

    while len(dq) != 0:

        r, c = dq.popleft()

        for nr, nc in ([r, c + 1], [r, c - 1], [r + 1, c], [r - 1, c]):

            if 0 <= nr < len(G) and 0 <= nc < len(G[0]) and G[nr][nc] == 1:

                G[nr][nc] = 0

                dq.append((nr, nc))

n_test = int(input())

for _ in range(n_test):

    N, M, E = map(int, input().split())

    G = [[0] * M for _ in range(N)]

    for _ in range(E):

        r, c = map(int, input().split())

        G[r][c] = 1

       

    count = 0

    for i in range(N):

        for j in range(M):

            if G[i][j]:

                floodfill(G, i, j)

                count += 1

    print(count)

BJ_1926 그림 (Silver I) 

from collections import deque

def floodfill(G, r, c):

    dq, visited = deque([(r, c)]), set([(r, c)])

    G[r][c] = 0

    while len(dq) != 0:

        r, c = dq.popleft()

        for nr, nc in ([r, c + 1], [r, c - 1], [r + 1, c], [r - 1, c]):

            if 0 <= nr < len(G) and 0 <= nc < len(G[0]) and G[nr][nc] == 1:

                G[nr][nc] = 0

                visited.add((nr, nc))

                dq.append((nr, nc))

    return len(visited)

N, M = map(int, input().split())

G = [list(map(int, input().split())) for _ in range(N)]

mx_size, count = 0, 0

for i in range(N):

    for j in range(M):

        if G[i][j] == 1:

            count += 1

            mx_size = max(mx_size, floodfill(G, i, j))

           

print(count)

print(mx_size)

BJ_2146 다리 만들기 (Gold III) 

import sys

from collections import deque

input = sys.stdin.readline

def floodfill(G, i, j, gid):

    q = deque([(i, j)])

    G[i][j] = gid

    while q:

        r, c = q.popleft()

        for nr, nc in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:

            if 0 <= nr < len(G) and 0 <= nc < len(G) and G[nr][nc] == 1:

                G[nr][nc] = gid

                q.append((nr, nc))

def get_distance(G):

    loop = 0

    dq = deque([(r, c) for r in range(len(G)) for c in range(len(G)) if G[r][c] != 0])

    while dq:

        loop += 1

        for _ in range(len(dq)):

            r, c = dq.popleft()

            for nr, nc in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:

                if 0 <= nr < len(G) and 0 <= nc < len(G):

                    if G[nr][nc] == 0:

                        G[nr][nc] = G[r][c]

                        dq.append((nr, nc))

                    elif G[nr][nc] < G[r][c]:

                        return loop * 2 - 2

                    elif G[nr][nc] > G[r][c]:

                        return loop * 2 - 1

n = int(input())

G = [list(map(int, input().split())) for _ in range(n)]

gid = -1

for i in range(len(G)):

    for j in range(len(G)):

        if G[i][j] > 0:

            floodfill(G, i, j, gid)

            gid -= 1

print(get_distance(G))

BJ_2206 벽 부수고 이동하기 (Gold IV) 

from collections import deque

def bfs(G, r, c):

    dq = deque([[0, 0, 1]])

    dp = [[[0] * 2 for i in range(m)] for i in range(n)]

    dp[r][c][1] = 1

    while dq:

        a, b, w = dq.popleft()

        if a == n - 1 and b == m - 1:

            return dp[a][b][w]

        for r, c in [(a + 1, b), (a, b + 1), (a - 1, b), (a, b - 1)]:

            if 0 <= r < n and 0 <= c < m:

                if G[r][c] == '1' and w == 1:

                    dp[r][c][0] = dp[a][b][1] + 1

                    dq.append([r, c, 0])

                elif G[r][c] == '0' and dp[r][c][w] == 0:

                    dp[r][c][w] = dp[a][b][w] + 1

                    dq.append([r, c, w])

    return -1

n, m = map(int, input().split())

G = [input() for _ in range(n)]

print(bfs(G, 0, 0))

   

Tree | Trie

BJ_11725 트리의 부모 찾기 (Silver II) 

import sys

sys.setrecursionlimit(10**9)

def dfs(G, start, node2head):

    for adj in sorted(G[start]):

        if adj not in node2head:

            node2head[adj] = start

            dfs(G, adj, node2head)

N = int(input())

G = [[] for i in range(N+1)]

for _ in range(N - 1):

    a, b = map(int, input().split())

    G[a].append(b)

    G[b].append(a)

node2head = {1 : 0}

dfs(G, 1, node2head)

for i in range(2, N + 1):

    print(node2head[i])

BJ_1068 트리 (Silver I) 

def dfs(v):

    if len(G[v]) == 0:

        return 1

    else:

        return sum(dfs(child) for child in G[v])

           

n = int(input())

G = [[] for _ in range(52)]

li = list(map(int,input().split()))

t = int(input())

for v, parent in enumerate(li):

    if parent == -1:

        start = v

    elif v != t:

        G[parent].append(v)

       

if start != t:

    print(dfs(start))

else :

    print(0)

BJ_1991 트리 순회 (Silver I) 

# traversal

# inorder          left, root, right

# preorder         root, left, right

# postorder         left, right, root

import sys

sys.setrecursionlimit(1000000)

 

n = int(input())

data2node = dict()

 

class Node:

    def __init__(self, data, left = None, right = None):

        self.data = data

        self.left = left

        self.right = right

       

def dfs(node, debug):

    if not node:

        return

    if debug == "pre":

        print(node.data, end='')

    if node.left:

        dfs(data2node[node.left.data], debug)

    if debug == "in":

        print(node.data, end='')

    if node.right:

        dfs(data2node[node.right.data], debug)

    if debug == "post":

        print(node.data, end='')

   

for i in range(n):

    a, b, c = input().split()

    if b != '.':

        data2node[b] = Node(b)

    if c!= '.':

        data2node[c] = Node(c)

    data2node[a] = Node(a, data2node.get(b), data2node.get(c))

           

for order in ["pre", "in", "post"]:

    dfs(data2node['A'], order)

    print()

BJ_1167 트리의 지름 (Gold III) 

import sys

input = sys.stdin.readline

def dfs(G, v, result):

    for e, d in G[v]:

        if result[e] == 0:

            result[e] = result[v] + d

            dfs(G, e, result)

N = int(input())

G = [[] for _ in range(N + 1)]

for _ in range(N):

    path = list(map(int, input().split()))

    for i in range(1, len(path) - 2, 2):

        G[path[0]].append([path[i], path[i + 1]])

root2dist = [0 for _ in range(N + 1)]

dfs(G, 1, root2dist)

root2dist[1]=0

index = root2dist.index(max(root2dist))

leaf2dist = [0 for _ in range(N + 1)]

dfs(G, index, leaf2dist)

leaf2dist[index] = 0

print(max(leaf2dist))

BJ_1967 트리의 지름 (Gold II)

import sys

from collections import deque

input = sys.stdin.readline

def bfs(G, x):

    dq = deque([x])

    dist = [-1 for _ in range(n)]

    dist[x] = 0

    while dq:

        x = dq.popleft()

        for w, nx in G[x]:

            if dist[nx] == -1:

                dist[nx] = dist[x] + w

                dq.append(nx)

    return max(dist), dist.index(max(dist))

n = int(input())

G = [[] for _ in range(n)]

for i in range(n-1):

    x, y, w = map(int, input().split())

    G[x-1].append([w, y-1])

    G[y-1].append([w, x-1])

print(bfs(G, bfs(G, 0)[1])[0])

BJ_2533 사회망 서비스(SNS) (Gold II) 

import sys

input = sys.stdin.readline

sys.setrecursionlimit(10**9)

def dfs(cur, visited):

    visited.add(cur)

    dp[cur][0]=1

    dp[cur][1]=0

    for adj in G[cur]:

        if adj not in visited:

            dfs(adj, visited)

            dp[cur][0]+=dp[adj][1]

            dp[cur][1]+=max(dp[adj][0],dp[adj][1])

           

N=int(input())

G=[[] for _ in range(N)]

for _ in range(N-1):

    u,v=map(int,input().split())

    G[u - 1].append(v - 1)

    G[v - 1].append(u - 1)

dp=[[0,0] for _ in range(N)] # contain / not

dfs(0, set())

print(dp)

print(N-max(dp[0][0], dp[0][1]))

Dijkstra | Bellman | Floyd

BJ_1916 최소비용 구하기 (Gold V)

from heapq import heappush, heappop

def dijkstra(G, start):

    dp = [0 if v == start else float('inf') for v in range(len(G))]

   

    heap = [(0, start)]

    while heap:

        w, n = heappop(heap)

        for n_n, wei in G[n]:

            n_w = wei + w

            if n_w < dp[n_n]:

                dp[n_n] = n_w

                heappush(heap, [n_w, n_n])

    return dp

V, E = int(input()), int(input())

G = [[] for _ in range(V)]

for _ in range(E):

    u, v, w = map(int, input().split())

    G[u - 1].append((v - 1, w))

start, end = map(int, input().split())

print(dijkstra(G, start - 1)[end - 1])

BJ_1753 최단경로 (Gold V) 

from heapq import heappush, heappop

def dijkstra(G, start):

    dp = [0 if v == start else float('inf') for v in range(len(G))]

   

    heap = [(0, start)]

    while heap:

        w, n = heappop(heap)

        for n_n, wei in G[n]:

            n_w = wei + w

            if n_w < dp[n_n]:

                dp[n_n] = n_w

                heappush(heap, [n_w, n_n])

    return dp

v, e = map(int, input().split())

k = int(input())

G = [[] for _ in range(v + 1)]

for i in range(e):

    u, v, w = map(int, input().split())

    G[u].append([v, w])

for i in dijkstra(G, k)[1:]:

    print(i if i != float('inf') else "INF")

BJ_1504 특정한 최단 경로 (Gold IV)

from heapq import heappush, heappop

def dijkstra(G, start):

    dp = [0 if v == start else float('inf') for v in range(len(G))]

   

    heap = [(0, start)]

    while heap:

        w, n = heappop(heap)

        for n_n, wei in G[n]:

            n_w = wei + w

            if n_w < dp[n_n]:

                dp[n_n] = n_w

                heappush(heap, [n_w, n_n])

               

    return dp

n, m = map(int, input().split())

G = [[] for _ in range(n)]

for _ in range(m):

    a, b, c = map(int, input().split())

    G[a-1].append([b-1, c])

    G[b-1].append([a-1, c])

x, y = map(int, input().split())

path1 = dijkstra(G, 0)[x-1] + dijkstra(G, x-1)[y-1] + dijkstra(G, y-1)[n-1]

path2 = dijkstra(G, 0)[y-1] + dijkstra(G, y-1)[x-1] + dijkstra(G, x-1)[n-1]

ans = min(path1, path2)

print(ans if ans < float('inf') else "-1")

BJ_1719 택배 (Gold IV) 

from heapq import heappush, heappop

import sys

input = sys.stdin.readline

def dijkstra(G, start, shortests):

    heap = [(0, start)]

    dp = [0 if start == i else float('inf') for i in range(n + 1)]

    while heap:

        w, v = heappop(heap)

        for adj, nw in G[v].items():

            wei = nw + w

            if dp[adj] > wei:

                dp[adj] = wei

                heappush(heap, (wei, adj))

                shortests[adj][start] = v

    return shortests

               

n, m = map(int, input().split())

G = [{} for i in range(n + 1)]

shortests = [[0] * n for i in range(n)]

for i in range(m):

    u, v, w = map(int, input().split())

    G[u - 1][v - 1] = w

    G[v - 1][u - 1] = w

   

for i in range(n):

    dijkstra(G, i, shortests)

for i in range(n):

    for j in range(n):

        if i == j:

            print("-", end=" ")

        else:

            print(shortests[i][j] + 1, end=" ")

    print()

BJ_2665 미로만들기 (Gold IV) 

from heapq import heappush, heappop

from collections import defaultdict

def dijkstra(G):

    dp = defaultdict(lambda : float('inf'), {(0, 0) : 0})

    heap = [(0, 0, 0)]

    while heap:

        w, r, c = heappop(heap)

        for nr, nc in [(r + 1, c), (r, c + 1), (r - 1, c), (r, c - 1)]:

            if 0 <= nr < len(G) and 0 <= nc < len(G):

                nw = w + (0 if G[r][c] == '1' else 1)

                if nw < dp[(nr, nc)]:

                    dp[(nr, nc)] = nw

                    heappush(heap, (nw, nr, nc))

    return dp

N = int(input())

G = [input() for _ in range(N)]

print(dijkstra(G)[(len(G) - 1, len(G) - 1)])

Single source shortest path in

Can be used to detect negative-weight cycles

def bellman_ford(G, source):

    dist, pre = dict(), dict()

    for node in G:

        dist[node], pre[node] = float('inf'), None

    dist[source] = 0

    for _ in range(len(G) - 1):

        for node in G:

            for nei in G[node]:

                if dist[nei] > dist[node] + G[node][nei]:

                    dist[nei], pre[nei] = dist[node] + G[node][nei], node

    for node in G:

        for nei in G[node]:

            assert dist[nei] <= dist[node] + G[node][nei], "Negative weight cycle."

 

    return dist, pre

all pairs shortest pathSoftest path from every pair in O(V^3)

BJ_11403 경로 찾기 (Silver I) 

N = int(input())

G = [input().split() for _ in range(N)]

 

for i in range(N) :

    for j in range(N) :

        for k in range(N):

            if G[j][i] == '1' and G[i][k] == '1':

                G[j][k] = '1'

               

for i in range(N):

    print(' '.join(G[i]))

BJ_1389 케빈 베이컨의 6단계 법칙 (Silver I) 

V, E = map(int, input().split())

G = [[float('inf')] * V for _ in range(V)]

for i in range(V):

    G[i][i] = 0

for _ in range(E):

    u, v = map(int, input().split())

    G[u - 1][v - 1] = 1

    G[v - 1][u - 1] = 1

   

for i in range(V):

    for j in range(V):

        for k in range(V):

            if G[j][i] + G[i][k] < G[j][k]:

                G[j][k] = G[j][i] + G[i][k]

bacon_scores = [sum(li) for li in G]

print(bacon_scores.index(min(bacon_scores)) + 1)

BJ_11404 플로이드 (Gold IV) 

V, E = int(input()), int(input())

G = [[float('inf')] * V for _ in range(V)]

for _ in range(E):

    u, v, w = map(int, input().split())

    G[u - 1][v - 1] = min(w, G[u - 1][v - 1])

   

for i in range(V):

    for j in range(V):

        for k in range(V):

            if G[j][i] + G[i][k] < G[j][k]:

                G[j][k] = G[j][i] + G[i][k]

               

for i in range(V):

    for j, v in enumerate(G[i]):

        if i == j or v == float('inf'):

            print(0, end=' ')

        else:

            print(v, end=' ')

    print()

SCC | disjoint_set

Kosaraju's Algorithm Graph Algorithm

vector<int> v;

int find(int a) {

    if (v[a] != a)    return v[a] = find(v[a]);

    return a;

}

void unions(int a, int b) {

    v[find(b)] = find(a);

}

BJ_1717 집합의 표현 (Gold IV) 

class UF:

    def __init__(self, N):

        self.parent = list(range(N))

        self.size = [1] * N

       

    def find(self, x):

        if self.parent[x] != x:

            self.parent[x] = self.find(self.parent[x])

        return self.parent[x]

    def union(self, x, y):

        px, py = self.find(x), self.find(y)

        if px != py:

            size_x, size_y = self.size[px], self.size[py]

            if size_x < size_y:

                self.parent[px] = py

                self.size[py] += size_x

            else:

                self.parent[py] = px

                self.size[px] += size_y

               

n, m = map(int, input().split())

uf = UF(n)

for _ in range(m):

    t, a, b = map(int, input().split())

    a -= 1; b -= 1

    if t == 0:

        uf.union(a, b)

    else:

        print("YES" if uf.find(a) == uf.find(b) else "NO")

BJ_1197 최소 스패닝 트리 (Gold IV) 

class UF:

    def __init__(self, N):

        self.parent = list(range(N))

        self.size = [1] * N

       

    def find(self, x):

        if self.parent[x] != x:

            self.parent[x] = self.find(self.parent[x])

        return self.parent[x]

    def union(self, x, y):

        px, py = self.find(x), self.find(y)

        if px != py:

            size_x, size_y = self.size[px], self.size[py]

            if size_x < size_y:

                self.parent[px] = py

                self.size[py] += size_x

            else:

                self.parent[py] = px

                self.size[px] += size_y

V, E = map(int, input().split())

uf = UF(V)

weight_u_v = []

for _ in range(E):

    u, v, w = map(int, input().split())

    weight_u_v.append((w, u - 1, v - 1))

total = 0

weight_u_v.sort()

for weight, u, v in weight_u_v:

    if uf.find(u) != uf.find(v):

        total += weight

        uf.union(u, v)

       

print(total)

BJ_4195 친구 네트워크 (Gold II) 

class UF:

    def __init__(self, N):

        self.parent = list(range(N))

        self.size = [1] * N

       

    def find(self, x):

        if self.parent[x] != x:

            self.parent[x] = self.find(self.parent[x])

        return self.parent[x]

    def union(self, x, y):

        px, py = self.find(x), self.find(y)

        if px != py:

            size_x, size_y = self.size[px], self.size[py]

            if size_x < size_y:

                self.parent[px] = py

                self.size[py] += size_x

            else:

                self.parent[py] = px

                self.size[px] += size_y

for _ in range(int(input())):

    N = int(input())

    name2idx, names = {}, [input() for _ in range(N)]

    uf = UF(N * 2)

    for name in names:

        a, b = name.split()

        if a not in name2idx:

            name2idx[a] = len(name2idx)

        if b not in name2idx:

            name2idx[b] = len(name2idx)

        a, b = name2idx[a], name2idx[b]

        uf.union(a, b)

        print(max(uf.size[uf.find(a)], uf.size[uf.find(b)]))

BJ_2150 Strongly Connected Component (Platinum V)

import sys

sys.setrecursionlimit(10000)

def dfs(G, start, visited, stk = None):

    visited.add(start)

    for adj in G[start]:

        if adj not in visited:

            dfs(G, adj, visited, stk)

           

    if stk != None:

        stk.append(start)

   

V, E = map(int, input().split())

G, G_inv = [[] for _ in range(V)], [[] for _ in range(V)]

for _ in range(E):

    v1, v2 = map(int, input().split())

    G[v1 - 1].append(v2 - 1)

    G_inv[v2 - 1].append(v1 - 1)

visited, stk = set(), []

for v in range(V):

    if v not in visited:

        dfs(G, v, visited, stk)

   

visited, SCCs, scced = set(), [], set()

for v in reversed(stk):

    if v not in visited:

        dfs(G_inv, v, visited)

        SCCs.append(visited - scced)

        scced |= visited

   

print(len(SCCs))

for SCC in sorted(SCCs, key=lambda li: min(li)):

    print(*sorted(SCC), -1)

LC_952 largest-component-size-by-common-factor (Hard) 

import collections

import math

class UF:

    def __init__(self, N):

        self.parent = list(range(N))

        self.size = [1] * N

       

    def find(self, x):

        if self.parent[x] != x:

            self.parent[x] = self.find(self.parent[x])

        return self.parent[x]

    def union(self, x, y):

        px, py = self.find(x), self.find(y)

        if px != py:

            size_x, size_y = self.size[px], self.size[py]

            if size_x < size_y:

                self.parent[px] = py

                self.size[py] += size_x

            else:

                self.parent[py] = px

                self.size[px] += size_y

class Solution:

    def largestComponentSize(self, A: List[int]) -> int:

        factor2i = collections.defaultdict(int)

        uf = UF(len(A))

        for i, num in enumerate(A):

            for factor in range(2, int(math.sqrt(num) + 1)):

                if num % factor == 0:

                    for fac in (factor, num // factor):

                        if fac in factor2i:

                            uf.union(i, factor2i[fac])

                        else:

                            factor2i[fac] = i

            if num not in factor2i:

                factor2i[num] = i

            else:

                uf.union(i, factor2i[num])

        return max(uf.size)

Topological | articulation

BJ_1005 ACM Craft (Gold III) 

import sys

input = sys.stdin.readline

def topologicalSort(G):

    indegree = [0] * N

    for dic in G:

        for adj in dic.keys():

            indegree[adj] += 1

           

    order, id2cost = [], [0] * N

    for i in range(N):

        if indegree[i] == 0:

            id2cost[i] = D[i]

            order.append(i)

    for v in order:

        for adj, cost in G[v].items():

            id2cost[adj] = max(id2cost[adj], id2cost[v] + cost)

            indegree[adj] -= 1

            if indegree[adj] == 0:

                order.append(adj)

    return id2cost

T = int(input())

for _ in range(T):

    N, K = map(int, input().split())

    D = list(map(int, input().split()))

    G = [{} for _ in range(N)]

    for _ in range(K):

        X, Y = map(int, input().split())

        G[X - 1][Y - 1] = D[Y - 1]

   

    W = int(input()) - 1

    print(topologicalSort(G)[W])

BJ_1516 게임 개발 (Gold III) 

N, costs = int(input()), []

G, G_r  = [[] for i in range(N)], [[] for i in range(N)]

wait = [0] * N

for u in range(N):

    li = list(map(int, input().split()))

    costs.append(li[0])

    for v in li[1:-1]:

        G[v - 1].append(u)

        G_r[u].append(v - 1)

        wait[u] += 1

   

bfs = [n for n in range(N) if wait[n] == 0]

for i in bfs:

    for j in G[i]:

        wait[j] -= 1

        if wait[j] == 0:

            bfs.append(j)

for i in bfs:

    costs[i] += max([0] + [costs[j] for j in G_r[i]])

print(*costs, sep='\n')

BJ_2252 줄 세우기 (Gold II) 

N, M = map(int, input().split())

G = [[] for i in range(N + 1)]

wait = [-1] + [0] * (N)

for _ in range(M):

    u, v = map(int, input().split())

    G[u].append(v)

    wait[v] += 1

   

bfs = [n for n in range(N + 1) if wait[n] == 0]

print(*bfs, end=' ')

for i in bfs:

    for j in G[i]:

        wait[j] -= 1

        if wait[j] == 0:

            print(j, end=' ')

            bfs.append(j)

LC_207 course-schedule

def canFinish(n, prerequisites):

    G = [[] for i in range(n)]

    degree = [0] * n

    for i, j in prerequisites:

        G[i].append(j)                                                # Take i before j

        degree[j] += 1

    bfs = [i for i in range(n) if degree[i] == 0]

    for i in bfs:

        for j in G[i]:

            degree[j] -= 1

            if degree[j] == 0:

                bfs.append(j)

    return len(bfs) == n

case v = root

vertex will be the point of articulation iff this vertex has more than one child.

case v ≠ root.

During DFS, (v, to) is articulation iff none of the vertices to or its descendents in the DFS traversal tree has a back-edge to any of the ancestors of v, then v is an articulation point.

visited time ≤ low time of adjacent vertex

Branch and Bound | ILP

Flow Network | Targan

BJ_2188 축사 배정 (Platinum IV) 

def dfs(G, start, visited):

    if start not in visited:

        visited.add(start)

        for adj in G[start]:

            if adj not in cow2home or dfs(G, cow2home[adj], visited):

                cow2home[adj] = start

                return 1

    return 0

n_home, n_cow = map(int, input().split())

G = [[] for _ in range(n_home)]

cow2home = {}

for home in range(n_home):

    for cow in list(map(int, input().split()))[1:]:

        G[home].append(cow - 1)

for i in range(n_home):

    dfs(G, i, set())

print(len(cow2home))

BJ_11375 열혈강호 (Platinum IV)

def dfs(G, start, visited, ppl2work):

    if start not in visited:

        visited.add(start)

        for adj in G[start]:

            if adj not in ppl2work or dfs(G, ppl2work[adj], visited, ppl2work):

                ppl2work[adj] = start

                return 1

    return 0

n_people, n_work = map(int, input().split())

G = [[] for _ in range(n_people)]

ppl2work = {}

for home in range(n_people):

    for cow in list(map(int, input().split()))[1:]:

        G[home].append(cow - 1)

for i in range(n_people):

    dfs(G, i, set(), ppl2work)

print(len(ppl2work))

vector<vector<int>> criticalConnections(int n, vector<vector<int>>& connections) {

        vector<bool> vi(n, false);

        vector<int> disc(n, 0), low(n, 0), parent(n, -1);

        vector<vector<int>> g(n, vector<int>()), res;

        for (auto& p : connections) {

            g[p.front()].push_back(p.back());

            g[p.back()].push_back(p.front());

        }

        for (int i = 0; i < n; ++i) {

            if (vi[i]) continue;

            h(i, vi, disc, low, parent, g, res);

        }

        return res;

    }

    void h(int u, vector<bool>& vi, vector<int>& disc, vector<int>& low, vector<int>& parent, vector<vector<int>>& g, vector<vector<int>>& res) {

        static int time = 0;

        vi[u] = true;

        disc[u] = low[u] = ++time;

        for (int v : g[u]) {

            if (!vi[v]) {

                parent[v] = u;

                h(v, vi, disc, low, parent, g, res);

                low[u] = min(low[u], low[v]);

                if (low[v] > disc[u]) {

                    res.push_back({u, v});

                }

            } else if (v != parent[u]) {

                low[u] = min(low[u], disc[v]);

            }

        }

    }

[16] concurrency

Lock | Semaphore

LC_1114 print-in-order

from threading import Lock

class Foo:

    def __init__(self):

        self.locks = (Lock(),Lock())

        self.locks[0].acquire()

        self.locks[1].acquire()

       

    def first(self, printFirst):

        printFirst()

        self.locks[0].release()

       

    def second(self, printSecond):

        with self.locks[0]:

            printSecond()

            self.locks[1].release()

           

           

    def third(self, printThird):

        with self.locks[1]:

            printThird()

LC_1195 fizz-buzz-multithreaded

from threading import Semaphore

class FizzBuzz(object):

    def __init__(self, n):

        self.n = n

        self.sem0 = Semaphore(1)

        self.sem3 = Semaphore(0)

        self.sem5 = Semaphore(0)

        self.sem15 = Semaphore(0)

    def fizz(self, printFizz):

        for i in range(3, self.n + 1, 3):

            if i % 15:

                self.sem3.acquire()

                printFizz()

                self._release(i+1)

               

    def buzz(self, printBuzz):

        for i in range(5, self.n + 1, 5):

            if i % 15:

                self.sem5.acquire()

                printBuzz()

                self._release(i+1)

   

    def fizzbuzz(self, printFizzBuzz):

        for i in range(15, self.n + 1, 15):

            self.sem15.acquire()

            printFizzBuzz()

            self._release(i+1)

    def number(self, printNumber):

        for i in range(1, self.n + 1):

            if i % 3 and i % 5:

                self.sem0.acquire()

                printNumber(i)

                self._release(i+1)

   

    def _release(self, i):

        if i % 3 and i % 5:

            self.sem0.release()

        elif i % 5:

            self.sem3.release()

        elif i % 3:

            self.sem5.release()

        else:

            self.sem15.release()

LC_1115 print-foobar-alternately 

from threading import Semaphore

class FooBar:

    def __init__(self, n):

        self.n = n

        self.semF = Semaphore(1)

        self.semB = Semaphore(0)

    def foo(self, printFoo: 'Callable[[], None]') -> None:

        for i in range(self.n):

            self.semF.acquire()

            printFoo()

            self.semB.release()

    def bar(self, printBar: 'Callable[[], None]') -> None:

        for i in range(self.n):

            self.semB.acquire()

            printBar()

            self.semF.release()

LC_1116 print-zero-even-odd

from threading import Semaphore

class ZeroEvenOdd:

    def __init__(self, n):

        self.n = n

        self.semZ = Semaphore(1)

        self.semO = Semaphore(0)      

        self.semE = Semaphore(0)      

       

    def zero(self, printNumber: 'Callable[[int], None]') -> None:

        for i in range(self.n):

            self.semZ.acquire()

            printNumber(0)

            (self.semE if i % 2 else self.semO).release()

       

    def even(self, printNumber: 'Callable[[int], None]') -> None:

        for i in range(2, self.n + 1, 2):

            self.semE.acquire()

            printNumber(i)

            self.semZ.release()

       

    def odd(self, printNumber: 'Callable[[int], None]') -> None:

        for i in range(1, self.n + 1, 2):

            self.semO.acquire()

            printNumber(i)

            self.semZ.release()

Barrier

LC_1117 building-h2o

from threading import Barrier, Semaphore

class H2O:

    def __init__(self):

        self.b = Barrier(3)

        self.h = Semaphore(2)

        self.o = Semaphore(1)

    def hydrogen(self, releaseHydrogen: 'Callable[[], None]') -> None:

        self.h.acquire()

        self.b.wait()

        releaseHydrogen()

        self.h.release()

    def oxygen(self, releaseOxygen: 'Callable[[], None]') -> None:

        self.o.acquire()

        self.b.wait()

        releaseOxygen()

        self.o.release()

[17] Design

LC_365 design-twitter

class Twitter(object):

    def __init__(self):

        self.timer = itertools.count(step=-1)

        self.tweets = collections.defaultdict(collections.deque)

        self.followees = collections.defaultdict(set)

    def postTweet(self, userId, tweetId):

        self.tweets[userId].appendleft((next(self.timer), tweetId))

    def getNewsFeed(self, userId):

        tweets = heapq.merge(*(self.tweets[u] for u in self.followees[userId] | {userId}))

        return [t for _, t in heapq.nsmallest(10, tweets)]

    def follow(self, followerId, followeeId):

        self.followees[followerId].add(followeeId)

    def unfollow(self, followerId, followeeId):

        self.followees[followerId].discard(followeeId)


Shell

[2] input

Add | Subtract

BJ_1000 A+B (Bronze V) 

read a b

echo $(($a+$b))

read A B

echo $(($A+$B))

echo $(($A-$B))

echo $(($A*$B))

echo $(($A/$B))

echo $(($A%$B))

[3] Conditional

if, else | elif

BJ_15963 CASIO (Bronze IV) 

read a b

echo $(($a==$b))

BJ_9498 시험 성적 (Bronze IV)

read a

if [ $a -ge 90 ]; then

        echo "A"

elif [ $a -ge 80 ]; then

        echo "B"

elif [ $a -ge 70 ]; then

        echo "C"

elif [ $a -ge 60 ]; then

        echo "D"

else

        echo "F"

fi

[4] loops

for

BJ_2739 구구단 (Bronze III) 

read n

for i in {1..9}

do

  echo "$n * $i = $(($n*$i))"

done

BJ_2438 별찍기 (Bronze III) 

read N

for((i=1;i<=N;i++))

do

    for((j=1;j<=$i;j++))

    do

        printf "*"

    done

    echo

done

[7] tricks

LC_195 tenth-line

awk 'NR == 10' file.txt

C++

[1] Print

[2] input

iostream | cstdio

BJ_11719 그대로 출력하기 2 (Bronze I) 

#include <iostream>

int main() {

    char c;

    while((c = std::cin.get()) != -1) {

        std::cout << c;

    }

}

BJ_10951 A+B - 4 (Bronze III) 

#include <iostream>

#include <cstdio>

using namespace std;

int main() {

    int a, b;

    while (scanf("%d%d", &a, &b) != EOF)

        cout << a + b << endl;

}

[6] Sort

Merge | Quick

// Inversion Count : sum of (mid - i) during merge step

// Stable

// Linked List

void mergeSort(int arr[], int l, int r) {

    if (l < r) {

        int m = l+(r-l)/2;

        mergeSort(arr, l, m);

        mergeSort(arr, m+1, r);

 

        merge(arr, l, m, r);

    }

}

void merge(int arr[], int l, int m, int r) {

    int n1 = m - l + 1, n2 = r - m;

    int L[n1], R[n2];

    for (i = 0; i < n1; i++)

        L[i] = arr[l + i];

    for (j = 0; j < n2; j++)

        R[j] = arr[m + 1+ j];

    int i = 0, j = 0, k = l;

    while (i < n1 && j < n2) {

        if (L[i] <= R[j])

            arr[k++] = L[i++];

        else

            arr[k++] = R[j++];

    }

    while (i < n1)

        arr[k++] = L[i++];

    while (j < n2)

        arr[k++] = R[j++];

}

int partition (int arr[], int low, int high) {

    int pivot = arr[high]; // pivot

    int i = (low - 1); // Index of smaller element

 

    for (int j = low; j < high; j++) {

        if (arr[j] <= pivot) {

            i++;

            swap(&arr[i], &arr[j]);

        }

    }

    swap(&arr[i + 1], &arr[high]);

    return (i + 1);

}

 

void quickSort(int arr[], int low, int high) {

    if (low < high) {

        int pi = partition(arr, low, high);  

        quickSort(arr, low, pi - 1);

        quickSort(arr, pi + 1, high);

    }

}

Binary | bisect | QSelect

# Search in rotated array

def search(li, targ):

    lo, hi = 0, len(li) - 1

    while lo < hi:

        mi = (lo + hi) // 2

        if (li[0] > targ) ^ (li[0] > li[mi]) ^ (targ > li[mi]):

            lo = mi + 1

        else:

            hi = mi

    return lo if targ in li[lo:lo+1] else -1

[7] Tricks

io | Date

BJ_15552 빠른 A + B 

#include<iostream>

using namespace std;

int main() {

    cin.tie(NULL);

    ios::sync_with_stdio(false);

    int T;

    cin >> T;

    while (T--) {

        int A, B;

        cin >> A >> B;

        cout << A + B << '\n';

    }

}

                # Zellar’s formula

Shuffle

LC_384 shuffle-an-array/

void randomize (int arr[], int n) {

    srand (time(NULL));

    for (int i = n - 1; i > 0; i--)  {

        int j = rand() % (i + 1);

        swap(&arr[i], &arr[j]);

    }

}

[8] Math

Bigint | Mod

#include<iostream>

#include<string>

using namespace std;

int ans[10010];

int main() {

        string a, b;

        cin >> a >> b;

        int x = a.length() - 1;

        int y = b.length() - 1;

        int i = 0;

        for (i = 0; x >= 0 || y >= 0; i++) {

                if (x >= 0) ans[i] += a[x] - '0';

                if (y >= 0)ans[i] += b[y] - '0';

                if (ans[i] > 9) {

                        ans[i + 1]++;

                        ans[i]-=10;

                }

                x--;

                y--;

        }

        if (ans[i])cout << ans[i];

        while (i--) {

                cout << ans[i];

        }

}

//

long powmod(long base, long exp, long modulus) {

    base %= modulus;

    long result = 1;

    while (exp > 0) {

        if (exp & 1) result = (result * base) % modulus;

        base = (base * base) % modulus;

        exp >>= 1;

    }

    return result;

}

//

int factmod (int n, int p) {

    long long res = 1;

    while (n > 1) {

        res = (res * powmod (p-1, n/p, p)) % p;

        for (int i=2; i<=n%p; ++i)

            res=(res*i) %p;

        n /= p;

    }

    return int (res % p);

}

[12] dp

sparse table

// range GCD / minimum query

void buildSparseTable(int arr[], int N) {

    // initialize M for the intervals with length 1

    for (int i = 0; i < N; i++)

        lookup[i][0] = arr[i];

    // Compute values from smaller to bigger intervals

    for (int j = 1; (1 << j) - 1) < N; i ++) {

        for (int i = 0; (i + (1 << j) - 1) < N; i++) {

            lookup[i][j] = min(lookup[i][j - 1], lookup[i + (1 << (j - 1))][j - 1]);

        }

    }

}

int query (int L, int R) {

    int j = (int) log2(R - L + 1);

    return min(lookup[L][j], lookup[R - (1 << j) + 1][j];

}

[15]

articulation

//MAXN = maximum points in the graph

vector<int> g[MAXN];

bool used[MAXN];

int timer, tin[MAXN], fup[MAXN];

void dfs (int v, int p = -1) {

    used[v] = true;

    tin[v] = fup[v] = timer++;

    int children = 0;

    for (size_t i=0; i<g[v].size(); ++i) {

        int to = g[v][i];

        if (to == p)  continue;

        if (used[to])

            fup[v] = min (fup[v], tin[to]);

        else {

            dfs (to, v);

            fup[v] = min (fup[v], fup[to]);

            if (fup[to] >= tin[v] && p != -1)

                //v is articulation point

                ++children;

        }

    }

    if (p == -1 && children > 1)

        //v is articulation point

        }

int main() {

    int n;

    // read n and g

    timer = 0;

    for (int i=0; i<n; ++i)

        used[i] = false;

    dfs (0);

}


Web

https://www.youtube.com/watch?v=tZooW6PritE&list=PLuHgQVnccGMDZP7FJ_ZsUrdCGH68ppvPb 

https://www.youtube.com/watch?v=kN6mlybyTdA&list=PLuHgQVnccGMDMxfZEpLbzHPZUEwObEaZq&index=1 

Deep learning

Deep Learning in 5 minutes 

But what is a Neural Network? 


{% endblock body %}